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 9fcf5ef2aSThomas Huth * version 2 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 */ 19fcf5ef2aSThomas Huth #include "qemu/osdep.h" 20fcf5ef2aSThomas Huth #include "cpu.h" 21fcf5ef2aSThomas Huth #include "internal.h" 22fcf5ef2aSThomas Huth #include "qemu/host-utils.h" 23fcf5ef2aSThomas Huth #include "exec/helper-proto.h" 24fcf5ef2aSThomas Huth #include "crypto/aes.h" 2524f91e81SAlex Bennée #include "fpu/softfloat.h" 263f74b632SRichard Henderson #include "qapi/error.h" 273f74b632SRichard Henderson #include "qemu/guest-random.h" 28fcf5ef2aSThomas Huth 29fcf5ef2aSThomas Huth #include "helper_regs.h" 30fcf5ef2aSThomas Huth /*****************************************************************************/ 31fcf5ef2aSThomas Huth /* Fixed point operations helpers */ 32fcf5ef2aSThomas Huth 33f32899deSNikunj A Dadhania static inline void helper_update_ov_legacy(CPUPPCState *env, int ov) 34f32899deSNikunj A Dadhania { 35f32899deSNikunj A Dadhania if (unlikely(ov)) { 36f32899deSNikunj A Dadhania env->so = env->ov = 1; 37f32899deSNikunj A Dadhania } else { 38f32899deSNikunj A Dadhania env->ov = 0; 39f32899deSNikunj A Dadhania } 40f32899deSNikunj A Dadhania } 41f32899deSNikunj A Dadhania 42fcf5ef2aSThomas Huth target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb, 43fcf5ef2aSThomas Huth uint32_t oe) 44fcf5ef2aSThomas Huth { 45fcf5ef2aSThomas Huth uint64_t rt = 0; 46fcf5ef2aSThomas Huth int overflow = 0; 47fcf5ef2aSThomas Huth 48fcf5ef2aSThomas Huth uint64_t dividend = (uint64_t)ra << 32; 49fcf5ef2aSThomas Huth uint64_t divisor = (uint32_t)rb; 50fcf5ef2aSThomas Huth 51fcf5ef2aSThomas Huth if (unlikely(divisor == 0)) { 52fcf5ef2aSThomas Huth overflow = 1; 53fcf5ef2aSThomas Huth } else { 54fcf5ef2aSThomas Huth rt = dividend / divisor; 55fcf5ef2aSThomas Huth overflow = rt > UINT32_MAX; 56fcf5ef2aSThomas Huth } 57fcf5ef2aSThomas Huth 58fcf5ef2aSThomas Huth if (unlikely(overflow)) { 59fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 60fcf5ef2aSThomas Huth } 61fcf5ef2aSThomas Huth 62fcf5ef2aSThomas Huth if (oe) { 63f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 64fcf5ef2aSThomas Huth } 65fcf5ef2aSThomas Huth 66fcf5ef2aSThomas Huth return (target_ulong)rt; 67fcf5ef2aSThomas Huth } 68fcf5ef2aSThomas Huth 69fcf5ef2aSThomas Huth target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb, 70fcf5ef2aSThomas Huth uint32_t oe) 71fcf5ef2aSThomas Huth { 72fcf5ef2aSThomas Huth int64_t rt = 0; 73fcf5ef2aSThomas Huth int overflow = 0; 74fcf5ef2aSThomas Huth 75fcf5ef2aSThomas Huth int64_t dividend = (int64_t)ra << 32; 76fcf5ef2aSThomas Huth int64_t divisor = (int64_t)((int32_t)rb); 77fcf5ef2aSThomas Huth 78fcf5ef2aSThomas Huth if (unlikely((divisor == 0) || 79fcf5ef2aSThomas Huth ((divisor == -1ull) && (dividend == INT64_MIN)))) { 80fcf5ef2aSThomas Huth overflow = 1; 81fcf5ef2aSThomas Huth } else { 82fcf5ef2aSThomas Huth rt = dividend / divisor; 83fcf5ef2aSThomas Huth overflow = rt != (int32_t)rt; 84fcf5ef2aSThomas Huth } 85fcf5ef2aSThomas Huth 86fcf5ef2aSThomas Huth if (unlikely(overflow)) { 87fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 88fcf5ef2aSThomas Huth } 89fcf5ef2aSThomas Huth 90fcf5ef2aSThomas Huth if (oe) { 91f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 92fcf5ef2aSThomas Huth } 93fcf5ef2aSThomas Huth 94fcf5ef2aSThomas Huth return (target_ulong)rt; 95fcf5ef2aSThomas Huth } 96fcf5ef2aSThomas Huth 97fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 98fcf5ef2aSThomas Huth 99fcf5ef2aSThomas Huth uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe) 100fcf5ef2aSThomas Huth { 101fcf5ef2aSThomas Huth uint64_t rt = 0; 102fcf5ef2aSThomas Huth int overflow = 0; 103fcf5ef2aSThomas Huth 104fcf5ef2aSThomas Huth overflow = divu128(&rt, &ra, rb); 105fcf5ef2aSThomas Huth 106fcf5ef2aSThomas Huth if (unlikely(overflow)) { 107fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 108fcf5ef2aSThomas Huth } 109fcf5ef2aSThomas Huth 110fcf5ef2aSThomas Huth if (oe) { 111f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 112fcf5ef2aSThomas Huth } 113fcf5ef2aSThomas Huth 114fcf5ef2aSThomas Huth return rt; 115fcf5ef2aSThomas Huth } 116fcf5ef2aSThomas Huth 117fcf5ef2aSThomas Huth uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe) 118fcf5ef2aSThomas Huth { 119fcf5ef2aSThomas Huth int64_t rt = 0; 120fcf5ef2aSThomas Huth int64_t ra = (int64_t)rau; 121fcf5ef2aSThomas Huth int64_t rb = (int64_t)rbu; 122fcf5ef2aSThomas Huth int overflow = divs128(&rt, &ra, rb); 123fcf5ef2aSThomas Huth 124fcf5ef2aSThomas Huth if (unlikely(overflow)) { 125fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 126fcf5ef2aSThomas Huth } 127fcf5ef2aSThomas Huth 128fcf5ef2aSThomas Huth if (oe) { 129f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 130fcf5ef2aSThomas Huth } 131fcf5ef2aSThomas Huth 132fcf5ef2aSThomas Huth return rt; 133fcf5ef2aSThomas Huth } 134fcf5ef2aSThomas Huth 135fcf5ef2aSThomas Huth #endif 136fcf5ef2aSThomas Huth 137fcf5ef2aSThomas Huth 138fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 139fcf5ef2aSThomas Huth /* if x = 0xab, returns 0xababababababababa */ 140fcf5ef2aSThomas Huth #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff)) 141fcf5ef2aSThomas Huth 142b6cb41b2SDavid Gibson /* 143b6cb41b2SDavid Gibson * subtract 1 from each byte, and with inverse, check if MSB is set at each 144fcf5ef2aSThomas Huth * byte. 145fcf5ef2aSThomas Huth * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80 146fcf5ef2aSThomas Huth * (0xFF & 0xFF) & 0x80 = 0x80 (zero found) 147fcf5ef2aSThomas Huth */ 148fcf5ef2aSThomas Huth #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80)) 149fcf5ef2aSThomas Huth 150fcf5ef2aSThomas Huth /* When you XOR the pattern and there is a match, that byte will be zero */ 151fcf5ef2aSThomas Huth #define hasvalue(x, n) (haszero((x) ^ pattern(n))) 152fcf5ef2aSThomas Huth 153fcf5ef2aSThomas Huth uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) 154fcf5ef2aSThomas Huth { 155efa73196SNikunj A Dadhania return hasvalue(rb, ra) ? CRF_GT : 0; 156fcf5ef2aSThomas Huth } 157fcf5ef2aSThomas Huth 158fcf5ef2aSThomas Huth #undef pattern 159fcf5ef2aSThomas Huth #undef haszero 160fcf5ef2aSThomas Huth #undef hasvalue 161fcf5ef2aSThomas Huth 162b6cb41b2SDavid Gibson /* 1633f74b632SRichard Henderson * Return a random number. 164fcf5ef2aSThomas Huth */ 1653f74b632SRichard Henderson uint64_t helper_darn32(void) 166fcf5ef2aSThomas Huth { 1673f74b632SRichard Henderson Error *err = NULL; 1683f74b632SRichard Henderson uint32_t ret; 1693f74b632SRichard Henderson 1703f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1713f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1723f74b632SRichard Henderson error_get_pretty(err)); 1733f74b632SRichard Henderson error_free(err); 174fcf5ef2aSThomas Huth return -1; 175fcf5ef2aSThomas Huth } 176fcf5ef2aSThomas Huth 1773f74b632SRichard Henderson return ret; 1783f74b632SRichard Henderson } 1793f74b632SRichard Henderson 1803f74b632SRichard Henderson uint64_t helper_darn64(void) 181fcf5ef2aSThomas Huth { 1823f74b632SRichard Henderson Error *err = NULL; 1833f74b632SRichard Henderson uint64_t ret; 1843f74b632SRichard Henderson 1853f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1863f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1873f74b632SRichard Henderson error_get_pretty(err)); 1883f74b632SRichard Henderson error_free(err); 189fcf5ef2aSThomas Huth return -1; 190fcf5ef2aSThomas Huth } 191fcf5ef2aSThomas Huth 1923f74b632SRichard Henderson return ret; 1933f74b632SRichard Henderson } 194fcf5ef2aSThomas Huth 195fcf5ef2aSThomas Huth uint64_t helper_bpermd(uint64_t rs, uint64_t rb) 196fcf5ef2aSThomas Huth { 197fcf5ef2aSThomas Huth int i; 198fcf5ef2aSThomas Huth uint64_t ra = 0; 199fcf5ef2aSThomas Huth 200fcf5ef2aSThomas Huth for (i = 0; i < 8; i++) { 201fcf5ef2aSThomas Huth int index = (rs >> (i * 8)) & 0xFF; 202fcf5ef2aSThomas Huth if (index < 64) { 203a6a444a8SCédric Le Goater if (rb & PPC_BIT(index)) { 204fcf5ef2aSThomas Huth ra |= 1 << i; 205fcf5ef2aSThomas Huth } 206fcf5ef2aSThomas Huth } 207fcf5ef2aSThomas Huth } 208fcf5ef2aSThomas Huth return ra; 209fcf5ef2aSThomas Huth } 210fcf5ef2aSThomas Huth 211fcf5ef2aSThomas Huth #endif 212fcf5ef2aSThomas Huth 213fcf5ef2aSThomas Huth target_ulong helper_cmpb(target_ulong rs, target_ulong rb) 214fcf5ef2aSThomas Huth { 215fcf5ef2aSThomas Huth target_ulong mask = 0xff; 216fcf5ef2aSThomas Huth target_ulong ra = 0; 217fcf5ef2aSThomas Huth int i; 218fcf5ef2aSThomas Huth 219fcf5ef2aSThomas Huth for (i = 0; i < sizeof(target_ulong); i++) { 220fcf5ef2aSThomas Huth if ((rs & mask) == (rb & mask)) { 221fcf5ef2aSThomas Huth ra |= mask; 222fcf5ef2aSThomas Huth } 223fcf5ef2aSThomas Huth mask <<= 8; 224fcf5ef2aSThomas Huth } 225fcf5ef2aSThomas Huth return ra; 226fcf5ef2aSThomas Huth } 227fcf5ef2aSThomas Huth 228fcf5ef2aSThomas Huth /* shift right arithmetic helper */ 229fcf5ef2aSThomas Huth target_ulong helper_sraw(CPUPPCState *env, target_ulong value, 230fcf5ef2aSThomas Huth target_ulong shift) 231fcf5ef2aSThomas Huth { 232fcf5ef2aSThomas Huth int32_t ret; 233fcf5ef2aSThomas Huth 234fcf5ef2aSThomas Huth if (likely(!(shift & 0x20))) { 235fcf5ef2aSThomas Huth if (likely((uint32_t)shift != 0)) { 236fcf5ef2aSThomas Huth shift &= 0x1f; 237fcf5ef2aSThomas Huth ret = (int32_t)value >> shift; 238fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) { 239af1c259fSSandipan Das env->ca32 = env->ca = 0; 240fcf5ef2aSThomas Huth } else { 241af1c259fSSandipan Das env->ca32 = env->ca = 1; 242fcf5ef2aSThomas Huth } 243fcf5ef2aSThomas Huth } else { 244fcf5ef2aSThomas Huth ret = (int32_t)value; 245af1c259fSSandipan Das env->ca32 = env->ca = 0; 246fcf5ef2aSThomas Huth } 247fcf5ef2aSThomas Huth } else { 248fcf5ef2aSThomas Huth ret = (int32_t)value >> 31; 249af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 250fcf5ef2aSThomas Huth } 251fcf5ef2aSThomas Huth return (target_long)ret; 252fcf5ef2aSThomas Huth } 253fcf5ef2aSThomas Huth 254fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 255fcf5ef2aSThomas Huth target_ulong helper_srad(CPUPPCState *env, target_ulong value, 256fcf5ef2aSThomas Huth target_ulong shift) 257fcf5ef2aSThomas Huth { 258fcf5ef2aSThomas Huth int64_t ret; 259fcf5ef2aSThomas Huth 260fcf5ef2aSThomas Huth if (likely(!(shift & 0x40))) { 261fcf5ef2aSThomas Huth if (likely((uint64_t)shift != 0)) { 262fcf5ef2aSThomas Huth shift &= 0x3f; 263fcf5ef2aSThomas Huth ret = (int64_t)value >> shift; 264fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) { 265af1c259fSSandipan Das env->ca32 = env->ca = 0; 266fcf5ef2aSThomas Huth } else { 267af1c259fSSandipan Das env->ca32 = env->ca = 1; 268fcf5ef2aSThomas Huth } 269fcf5ef2aSThomas Huth } else { 270fcf5ef2aSThomas Huth ret = (int64_t)value; 271af1c259fSSandipan Das env->ca32 = env->ca = 0; 272fcf5ef2aSThomas Huth } 273fcf5ef2aSThomas Huth } else { 274fcf5ef2aSThomas Huth ret = (int64_t)value >> 63; 275af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 276fcf5ef2aSThomas Huth } 277fcf5ef2aSThomas Huth return ret; 278fcf5ef2aSThomas Huth } 279fcf5ef2aSThomas Huth #endif 280fcf5ef2aSThomas Huth 281fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 282fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 283fcf5ef2aSThomas Huth { 28479770002SRichard Henderson /* Note that we don't fold past bytes */ 285fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 286fcf5ef2aSThomas Huth 0x5555555555555555ULL); 287fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 288fcf5ef2aSThomas Huth 0x3333333333333333ULL); 289fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 290fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 291fcf5ef2aSThomas Huth return val; 292fcf5ef2aSThomas Huth } 293fcf5ef2aSThomas Huth 294fcf5ef2aSThomas Huth target_ulong helper_popcntw(target_ulong val) 295fcf5ef2aSThomas Huth { 29679770002SRichard Henderson /* Note that we don't fold past words. */ 297fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 298fcf5ef2aSThomas Huth 0x5555555555555555ULL); 299fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 300fcf5ef2aSThomas Huth 0x3333333333333333ULL); 301fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 302fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 303fcf5ef2aSThomas Huth val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 304fcf5ef2aSThomas Huth 0x00ff00ff00ff00ffULL); 305fcf5ef2aSThomas Huth val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 306fcf5ef2aSThomas Huth 0x0000ffff0000ffffULL); 307fcf5ef2aSThomas Huth return val; 308fcf5ef2aSThomas Huth } 309fcf5ef2aSThomas Huth #else 310fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 311fcf5ef2aSThomas Huth { 31279770002SRichard Henderson /* Note that we don't fold past bytes */ 313fcf5ef2aSThomas Huth val = (val & 0x55555555) + ((val >> 1) & 0x55555555); 314fcf5ef2aSThomas Huth val = (val & 0x33333333) + ((val >> 2) & 0x33333333); 315fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f); 316fcf5ef2aSThomas Huth return val; 317fcf5ef2aSThomas Huth } 318fcf5ef2aSThomas Huth #endif 319fcf5ef2aSThomas Huth 320fcf5ef2aSThomas Huth /*****************************************************************************/ 321fcf5ef2aSThomas Huth /* PowerPC 601 specific instructions (POWER bridge) */ 322fcf5ef2aSThomas Huth target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2) 323fcf5ef2aSThomas Huth { 324fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 325fcf5ef2aSThomas Huth 326fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 327fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 328fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 329fcf5ef2aSThomas Huth return INT32_MIN; 330fcf5ef2aSThomas Huth } else { 331fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 332fcf5ef2aSThomas Huth return tmp / (int32_t)arg2; 333fcf5ef2aSThomas Huth } 334fcf5ef2aSThomas Huth } 335fcf5ef2aSThomas Huth 336fcf5ef2aSThomas Huth target_ulong helper_divo(CPUPPCState *env, target_ulong arg1, 337fcf5ef2aSThomas Huth target_ulong arg2) 338fcf5ef2aSThomas Huth { 339fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 340fcf5ef2aSThomas Huth 341fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 342fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 343fcf5ef2aSThomas Huth env->so = env->ov = 1; 344fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 345fcf5ef2aSThomas Huth return INT32_MIN; 346fcf5ef2aSThomas Huth } else { 347fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 348fcf5ef2aSThomas Huth tmp /= (int32_t)arg2; 349fcf5ef2aSThomas Huth if ((int32_t)tmp != tmp) { 350fcf5ef2aSThomas Huth env->so = env->ov = 1; 351fcf5ef2aSThomas Huth } else { 352fcf5ef2aSThomas Huth env->ov = 0; 353fcf5ef2aSThomas Huth } 354fcf5ef2aSThomas Huth return tmp; 355fcf5ef2aSThomas Huth } 356fcf5ef2aSThomas Huth } 357fcf5ef2aSThomas Huth 358fcf5ef2aSThomas Huth target_ulong helper_divs(CPUPPCState *env, target_ulong arg1, 359fcf5ef2aSThomas Huth target_ulong arg2) 360fcf5ef2aSThomas Huth { 361fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 362fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 363fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 364fcf5ef2aSThomas Huth return INT32_MIN; 365fcf5ef2aSThomas Huth } else { 366fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 367fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 368fcf5ef2aSThomas Huth } 369fcf5ef2aSThomas Huth } 370fcf5ef2aSThomas Huth 371fcf5ef2aSThomas Huth target_ulong helper_divso(CPUPPCState *env, target_ulong arg1, 372fcf5ef2aSThomas Huth target_ulong arg2) 373fcf5ef2aSThomas Huth { 374fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 375fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 376fcf5ef2aSThomas Huth env->so = env->ov = 1; 377fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 378fcf5ef2aSThomas Huth return INT32_MIN; 379fcf5ef2aSThomas Huth } else { 380fcf5ef2aSThomas Huth env->ov = 0; 381fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 382fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 383fcf5ef2aSThomas Huth } 384fcf5ef2aSThomas Huth } 385fcf5ef2aSThomas Huth 386fcf5ef2aSThomas Huth /*****************************************************************************/ 387fcf5ef2aSThomas Huth /* 602 specific instructions */ 388fcf5ef2aSThomas Huth /* mfrom is the most crazy instruction ever seen, imho ! */ 389fcf5ef2aSThomas Huth /* Real implementation uses a ROM table. Do the same */ 390b6cb41b2SDavid Gibson /* 391b6cb41b2SDavid Gibson * Extremely decomposed: 392fcf5ef2aSThomas Huth * -arg / 256 393fcf5ef2aSThomas Huth * return 256 * log10(10 + 1.0) + 0.5 394fcf5ef2aSThomas Huth */ 395fcf5ef2aSThomas Huth #if !defined(CONFIG_USER_ONLY) 396fcf5ef2aSThomas Huth target_ulong helper_602_mfrom(target_ulong arg) 397fcf5ef2aSThomas Huth { 398fcf5ef2aSThomas Huth if (likely(arg < 602)) { 3995b27a92dSPaolo Bonzini #include "mfrom_table.inc.c" 400fcf5ef2aSThomas Huth return mfrom_ROM_table[arg]; 401fcf5ef2aSThomas Huth } else { 402fcf5ef2aSThomas Huth return 0; 403fcf5ef2aSThomas Huth } 404fcf5ef2aSThomas Huth } 405fcf5ef2aSThomas Huth #endif 406fcf5ef2aSThomas Huth 407fcf5ef2aSThomas Huth /*****************************************************************************/ 408fcf5ef2aSThomas Huth /* Altivec extension helpers */ 409fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 410fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 411fcf5ef2aSThomas Huth for (index = 0; index < ARRAY_SIZE(r->element); index++) 412fcf5ef2aSThomas Huth #else 413fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 414fcf5ef2aSThomas Huth for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--) 415fcf5ef2aSThomas Huth #endif 416fcf5ef2aSThomas Huth 417fcf5ef2aSThomas Huth /* Saturating arithmetic helpers. */ 418fcf5ef2aSThomas Huth #define SATCVT(from, to, from_type, to_type, min, max) \ 419fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 420fcf5ef2aSThomas Huth { \ 421fcf5ef2aSThomas Huth to_type r; \ 422fcf5ef2aSThomas Huth \ 423fcf5ef2aSThomas Huth if (x < (from_type)min) { \ 424fcf5ef2aSThomas Huth r = min; \ 425fcf5ef2aSThomas Huth *sat = 1; \ 426fcf5ef2aSThomas Huth } else if (x > (from_type)max) { \ 427fcf5ef2aSThomas Huth r = max; \ 428fcf5ef2aSThomas Huth *sat = 1; \ 429fcf5ef2aSThomas Huth } else { \ 430fcf5ef2aSThomas Huth r = x; \ 431fcf5ef2aSThomas Huth } \ 432fcf5ef2aSThomas Huth return r; \ 433fcf5ef2aSThomas Huth } 434fcf5ef2aSThomas Huth #define SATCVTU(from, to, from_type, to_type, min, max) \ 435fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 436fcf5ef2aSThomas Huth { \ 437fcf5ef2aSThomas Huth to_type r; \ 438fcf5ef2aSThomas Huth \ 439fcf5ef2aSThomas Huth if (x > (from_type)max) { \ 440fcf5ef2aSThomas Huth r = max; \ 441fcf5ef2aSThomas Huth *sat = 1; \ 442fcf5ef2aSThomas Huth } else { \ 443fcf5ef2aSThomas Huth r = x; \ 444fcf5ef2aSThomas Huth } \ 445fcf5ef2aSThomas Huth return r; \ 446fcf5ef2aSThomas Huth } 447fcf5ef2aSThomas Huth SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX) 448fcf5ef2aSThomas Huth SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX) 449fcf5ef2aSThomas Huth SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX) 450fcf5ef2aSThomas Huth 451fcf5ef2aSThomas Huth SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX) 452fcf5ef2aSThomas Huth SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX) 453fcf5ef2aSThomas Huth SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX) 454fcf5ef2aSThomas Huth SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX) 455fcf5ef2aSThomas Huth SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX) 456fcf5ef2aSThomas Huth SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX) 457fcf5ef2aSThomas Huth #undef SATCVT 458fcf5ef2aSThomas Huth #undef SATCVTU 459fcf5ef2aSThomas Huth 460fcf5ef2aSThomas Huth void helper_lvsl(ppc_avr_t *r, target_ulong sh) 461fcf5ef2aSThomas Huth { 462fcf5ef2aSThomas Huth int i, j = (sh & 0xf); 463fcf5ef2aSThomas Huth 46460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 46560594feaSMark Cave-Ayland r->VsrB(i) = j++; 466fcf5ef2aSThomas Huth } 467fcf5ef2aSThomas Huth } 468fcf5ef2aSThomas Huth 469fcf5ef2aSThomas Huth void helper_lvsr(ppc_avr_t *r, target_ulong sh) 470fcf5ef2aSThomas Huth { 471fcf5ef2aSThomas Huth int i, j = 0x10 - (sh & 0xf); 472fcf5ef2aSThomas Huth 47360594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 47460594feaSMark Cave-Ayland r->VsrB(i) = j++; 475fcf5ef2aSThomas Huth } 476fcf5ef2aSThomas Huth } 477fcf5ef2aSThomas Huth 478dedfaac7SRichard Henderson void helper_mtvscr(CPUPPCState *env, uint32_t vscr) 479fcf5ef2aSThomas Huth { 4809b5b74daSRichard Henderson env->vscr = vscr & ~(1u << VSCR_SAT); 4819b5b74daSRichard Henderson /* Which bit we set is completely arbitrary, but clear the rest. */ 4829b5b74daSRichard Henderson env->vscr_sat.u64[0] = vscr & (1u << VSCR_SAT); 4839b5b74daSRichard Henderson env->vscr_sat.u64[1] = 0; 484dedfaac7SRichard Henderson set_flush_to_zero((vscr >> VSCR_NJ) & 1, &env->vec_status); 485fcf5ef2aSThomas Huth } 486fcf5ef2aSThomas Huth 487cc2b90d7SRichard Henderson uint32_t helper_mfvscr(CPUPPCState *env) 488cc2b90d7SRichard Henderson { 4899b5b74daSRichard Henderson uint32_t sat = (env->vscr_sat.u64[0] | env->vscr_sat.u64[1]) != 0; 4909b5b74daSRichard Henderson return env->vscr | (sat << VSCR_SAT); 491cc2b90d7SRichard Henderson } 492cc2b90d7SRichard Henderson 4936175f5a0SRichard Henderson static inline void set_vscr_sat(CPUPPCState *env) 4946175f5a0SRichard Henderson { 4959b5b74daSRichard Henderson /* The choice of non-zero value is arbitrary. */ 4969b5b74daSRichard Henderson env->vscr_sat.u32[0] = 1; 4976175f5a0SRichard Henderson } 4986175f5a0SRichard Henderson 499fcf5ef2aSThomas Huth void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 500fcf5ef2aSThomas Huth { 501fcf5ef2aSThomas Huth int i; 502fcf5ef2aSThomas Huth 503fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 504fcf5ef2aSThomas Huth r->u32[i] = ~a->u32[i] < b->u32[i]; 505fcf5ef2aSThomas Huth } 506fcf5ef2aSThomas Huth } 507fcf5ef2aSThomas Huth 508fcf5ef2aSThomas Huth /* vprtybw */ 509fcf5ef2aSThomas Huth void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b) 510fcf5ef2aSThomas Huth { 511fcf5ef2aSThomas Huth int i; 512fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 513fcf5ef2aSThomas Huth uint64_t res = b->u32[i] ^ (b->u32[i] >> 16); 514fcf5ef2aSThomas Huth res ^= res >> 8; 515fcf5ef2aSThomas Huth r->u32[i] = res & 1; 516fcf5ef2aSThomas Huth } 517fcf5ef2aSThomas Huth } 518fcf5ef2aSThomas Huth 519fcf5ef2aSThomas Huth /* vprtybd */ 520fcf5ef2aSThomas Huth void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b) 521fcf5ef2aSThomas Huth { 522fcf5ef2aSThomas Huth int i; 523fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 524fcf5ef2aSThomas Huth uint64_t res = b->u64[i] ^ (b->u64[i] >> 32); 525fcf5ef2aSThomas Huth res ^= res >> 16; 526fcf5ef2aSThomas Huth res ^= res >> 8; 527fcf5ef2aSThomas Huth r->u64[i] = res & 1; 528fcf5ef2aSThomas Huth } 529fcf5ef2aSThomas Huth } 530fcf5ef2aSThomas Huth 531fcf5ef2aSThomas Huth /* vprtybq */ 532fcf5ef2aSThomas Huth void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b) 533fcf5ef2aSThomas Huth { 534fcf5ef2aSThomas Huth uint64_t res = b->u64[0] ^ b->u64[1]; 535fcf5ef2aSThomas Huth res ^= res >> 32; 536fcf5ef2aSThomas Huth res ^= res >> 16; 537fcf5ef2aSThomas Huth res ^= res >> 8; 5383c385a93SMark Cave-Ayland r->VsrD(1) = res & 1; 5393c385a93SMark Cave-Ayland r->VsrD(0) = 0; 540fcf5ef2aSThomas Huth } 541fcf5ef2aSThomas Huth 542fcf5ef2aSThomas Huth #define VARITH_DO(name, op, element) \ 543fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 544fcf5ef2aSThomas Huth { \ 545fcf5ef2aSThomas Huth int i; \ 546fcf5ef2aSThomas Huth \ 547fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 548fcf5ef2aSThomas Huth r->element[i] = a->element[i] op b->element[i]; \ 549fcf5ef2aSThomas Huth } \ 550fcf5ef2aSThomas Huth } 551fcf5ef2aSThomas Huth VARITH_DO(muluwm, *, u32) 552fcf5ef2aSThomas Huth #undef VARITH_DO 553fcf5ef2aSThomas Huth #undef VARITH 554fcf5ef2aSThomas Huth 555fcf5ef2aSThomas Huth #define VARITHFP(suffix, func) \ 556fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 557fcf5ef2aSThomas Huth ppc_avr_t *b) \ 558fcf5ef2aSThomas Huth { \ 559fcf5ef2aSThomas Huth int i; \ 560fcf5ef2aSThomas Huth \ 56105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 56205ee3e8aSMark Cave-Ayland r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \ 563fcf5ef2aSThomas Huth } \ 564fcf5ef2aSThomas Huth } 565fcf5ef2aSThomas Huth VARITHFP(addfp, float32_add) 566fcf5ef2aSThomas Huth VARITHFP(subfp, float32_sub) 567fcf5ef2aSThomas Huth VARITHFP(minfp, float32_min) 568fcf5ef2aSThomas Huth VARITHFP(maxfp, float32_max) 569fcf5ef2aSThomas Huth #undef VARITHFP 570fcf5ef2aSThomas Huth 571fcf5ef2aSThomas Huth #define VARITHFPFMA(suffix, type) \ 572fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 573fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) \ 574fcf5ef2aSThomas Huth { \ 575fcf5ef2aSThomas Huth int i; \ 57605ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 57705ee3e8aSMark Cave-Ayland r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \ 578fcf5ef2aSThomas Huth type, &env->vec_status); \ 579fcf5ef2aSThomas Huth } \ 580fcf5ef2aSThomas Huth } 581fcf5ef2aSThomas Huth VARITHFPFMA(maddfp, 0); 582fcf5ef2aSThomas Huth VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c); 583fcf5ef2aSThomas Huth #undef VARITHFPFMA 584fcf5ef2aSThomas Huth 585fcf5ef2aSThomas Huth #define VARITHSAT_CASE(type, op, cvt, element) \ 586fcf5ef2aSThomas Huth { \ 587fcf5ef2aSThomas Huth type result = (type)a->element[i] op (type)b->element[i]; \ 588fcf5ef2aSThomas Huth r->element[i] = cvt(result, &sat); \ 589fcf5ef2aSThomas Huth } 590fcf5ef2aSThomas Huth 591fcf5ef2aSThomas Huth #define VARITHSAT_DO(name, op, optype, cvt, element) \ 592fb11ae7dSRichard Henderson void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat, \ 593fb11ae7dSRichard Henderson ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \ 594fcf5ef2aSThomas Huth { \ 595fcf5ef2aSThomas Huth int sat = 0; \ 596fcf5ef2aSThomas Huth int i; \ 597fcf5ef2aSThomas Huth \ 598fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 599fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 600fcf5ef2aSThomas Huth } \ 601fcf5ef2aSThomas Huth if (sat) { \ 602fb11ae7dSRichard Henderson vscr_sat->u32[0] = 1; \ 603fcf5ef2aSThomas Huth } \ 604fcf5ef2aSThomas Huth } 605fcf5ef2aSThomas Huth #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \ 606fcf5ef2aSThomas Huth VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \ 607fcf5ef2aSThomas Huth VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element) 608fcf5ef2aSThomas Huth #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \ 609fcf5ef2aSThomas Huth VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \ 610fcf5ef2aSThomas Huth VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element) 611fcf5ef2aSThomas Huth VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb) 612fcf5ef2aSThomas Huth VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh) 613fcf5ef2aSThomas Huth VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw) 614fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub) 615fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh) 616fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw) 617fcf5ef2aSThomas Huth #undef VARITHSAT_CASE 618fcf5ef2aSThomas Huth #undef VARITHSAT_DO 619fcf5ef2aSThomas Huth #undef VARITHSAT_SIGNED 620fcf5ef2aSThomas Huth #undef VARITHSAT_UNSIGNED 621fcf5ef2aSThomas Huth 622fcf5ef2aSThomas Huth #define VAVG_DO(name, element, etype) \ 623fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 624fcf5ef2aSThomas Huth { \ 625fcf5ef2aSThomas Huth int i; \ 626fcf5ef2aSThomas Huth \ 627fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 628fcf5ef2aSThomas Huth etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \ 629fcf5ef2aSThomas Huth r->element[i] = x >> 1; \ 630fcf5ef2aSThomas Huth } \ 631fcf5ef2aSThomas Huth } 632fcf5ef2aSThomas Huth 633fcf5ef2aSThomas Huth #define VAVG(type, signed_element, signed_type, unsigned_element, \ 634fcf5ef2aSThomas Huth unsigned_type) \ 635fcf5ef2aSThomas Huth VAVG_DO(avgs##type, signed_element, signed_type) \ 636fcf5ef2aSThomas Huth VAVG_DO(avgu##type, unsigned_element, unsigned_type) 637fcf5ef2aSThomas Huth VAVG(b, s8, int16_t, u8, uint16_t) 638fcf5ef2aSThomas Huth VAVG(h, s16, int32_t, u16, uint32_t) 639fcf5ef2aSThomas Huth VAVG(w, s32, int64_t, u32, uint64_t) 640fcf5ef2aSThomas Huth #undef VAVG_DO 641fcf5ef2aSThomas Huth #undef VAVG 642fcf5ef2aSThomas Huth 643fcf5ef2aSThomas Huth #define VABSDU_DO(name, element) \ 644fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 645fcf5ef2aSThomas Huth { \ 646fcf5ef2aSThomas Huth int i; \ 647fcf5ef2aSThomas Huth \ 648fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 649fcf5ef2aSThomas Huth r->element[i] = (a->element[i] > b->element[i]) ? \ 650fcf5ef2aSThomas Huth (a->element[i] - b->element[i]) : \ 651fcf5ef2aSThomas Huth (b->element[i] - a->element[i]); \ 652fcf5ef2aSThomas Huth } \ 653fcf5ef2aSThomas Huth } 654fcf5ef2aSThomas Huth 655b6cb41b2SDavid Gibson /* 656b6cb41b2SDavid Gibson * VABSDU - Vector absolute difference unsigned 657fcf5ef2aSThomas Huth * name - instruction mnemonic suffix (b: byte, h: halfword, w: word) 658fcf5ef2aSThomas Huth * element - element type to access from vector 659fcf5ef2aSThomas Huth */ 660fcf5ef2aSThomas Huth #define VABSDU(type, element) \ 661fcf5ef2aSThomas Huth VABSDU_DO(absdu##type, element) 662fcf5ef2aSThomas Huth VABSDU(b, u8) 663fcf5ef2aSThomas Huth VABSDU(h, u16) 664fcf5ef2aSThomas Huth VABSDU(w, u32) 665fcf5ef2aSThomas Huth #undef VABSDU_DO 666fcf5ef2aSThomas Huth #undef VABSDU 667fcf5ef2aSThomas Huth 668fcf5ef2aSThomas Huth #define VCF(suffix, cvt, element) \ 669fcf5ef2aSThomas Huth void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \ 670fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 671fcf5ef2aSThomas Huth { \ 672fcf5ef2aSThomas Huth int i; \ 673fcf5ef2aSThomas Huth \ 67405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 675fcf5ef2aSThomas Huth float32 t = cvt(b->element[i], &env->vec_status); \ 67605ee3e8aSMark Cave-Ayland r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \ 677fcf5ef2aSThomas Huth } \ 678fcf5ef2aSThomas Huth } 679fcf5ef2aSThomas Huth VCF(ux, uint32_to_float32, u32) 680fcf5ef2aSThomas Huth VCF(sx, int32_to_float32, s32) 681fcf5ef2aSThomas Huth #undef VCF 682fcf5ef2aSThomas Huth 683fcf5ef2aSThomas Huth #define VCMP_DO(suffix, compare, element, record) \ 684fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 685fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 686fcf5ef2aSThomas Huth { \ 687fcf5ef2aSThomas Huth uint64_t ones = (uint64_t)-1; \ 688fcf5ef2aSThomas Huth uint64_t all = ones; \ 689fcf5ef2aSThomas Huth uint64_t none = 0; \ 690fcf5ef2aSThomas Huth int i; \ 691fcf5ef2aSThomas Huth \ 692fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 693fcf5ef2aSThomas Huth uint64_t result = (a->element[i] compare b->element[i] ? \ 694fcf5ef2aSThomas Huth ones : 0x0); \ 695fcf5ef2aSThomas Huth switch (sizeof(a->element[0])) { \ 696fcf5ef2aSThomas Huth case 8: \ 697fcf5ef2aSThomas Huth r->u64[i] = result; \ 698fcf5ef2aSThomas Huth break; \ 699fcf5ef2aSThomas Huth case 4: \ 700fcf5ef2aSThomas Huth r->u32[i] = result; \ 701fcf5ef2aSThomas Huth break; \ 702fcf5ef2aSThomas Huth case 2: \ 703fcf5ef2aSThomas Huth r->u16[i] = result; \ 704fcf5ef2aSThomas Huth break; \ 705fcf5ef2aSThomas Huth case 1: \ 706fcf5ef2aSThomas Huth r->u8[i] = result; \ 707fcf5ef2aSThomas Huth break; \ 708fcf5ef2aSThomas Huth } \ 709fcf5ef2aSThomas Huth all &= result; \ 710fcf5ef2aSThomas Huth none |= result; \ 711fcf5ef2aSThomas Huth } \ 712fcf5ef2aSThomas Huth if (record) { \ 713fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 714fcf5ef2aSThomas Huth } \ 715fcf5ef2aSThomas Huth } 716fcf5ef2aSThomas Huth #define VCMP(suffix, compare, element) \ 717fcf5ef2aSThomas Huth VCMP_DO(suffix, compare, element, 0) \ 718fcf5ef2aSThomas Huth VCMP_DO(suffix##_dot, compare, element, 1) 719fcf5ef2aSThomas Huth VCMP(equb, ==, u8) 720fcf5ef2aSThomas Huth VCMP(equh, ==, u16) 721fcf5ef2aSThomas Huth VCMP(equw, ==, u32) 722fcf5ef2aSThomas Huth VCMP(equd, ==, u64) 723fcf5ef2aSThomas Huth VCMP(gtub, >, u8) 724fcf5ef2aSThomas Huth VCMP(gtuh, >, u16) 725fcf5ef2aSThomas Huth VCMP(gtuw, >, u32) 726fcf5ef2aSThomas Huth VCMP(gtud, >, u64) 727fcf5ef2aSThomas Huth VCMP(gtsb, >, s8) 728fcf5ef2aSThomas Huth VCMP(gtsh, >, s16) 729fcf5ef2aSThomas Huth VCMP(gtsw, >, s32) 730fcf5ef2aSThomas Huth VCMP(gtsd, >, s64) 731fcf5ef2aSThomas Huth #undef VCMP_DO 732fcf5ef2aSThomas Huth #undef VCMP 733fcf5ef2aSThomas Huth 734fcf5ef2aSThomas Huth #define VCMPNE_DO(suffix, element, etype, cmpzero, record) \ 735fcf5ef2aSThomas Huth void helper_vcmpne##suffix(CPUPPCState *env, ppc_avr_t *r, \ 736fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 737fcf5ef2aSThomas Huth { \ 738fcf5ef2aSThomas Huth etype ones = (etype)-1; \ 739fcf5ef2aSThomas Huth etype all = ones; \ 740fcf5ef2aSThomas Huth etype result, none = 0; \ 741fcf5ef2aSThomas Huth int i; \ 742fcf5ef2aSThomas Huth \ 743fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 744fcf5ef2aSThomas Huth if (cmpzero) { \ 745fcf5ef2aSThomas Huth result = ((a->element[i] == 0) \ 746fcf5ef2aSThomas Huth || (b->element[i] == 0) \ 747fcf5ef2aSThomas Huth || (a->element[i] != b->element[i]) ? \ 748fcf5ef2aSThomas Huth ones : 0x0); \ 749fcf5ef2aSThomas Huth } else { \ 750fcf5ef2aSThomas Huth result = (a->element[i] != b->element[i]) ? ones : 0x0; \ 751fcf5ef2aSThomas Huth } \ 752fcf5ef2aSThomas Huth r->element[i] = result; \ 753fcf5ef2aSThomas Huth all &= result; \ 754fcf5ef2aSThomas Huth none |= result; \ 755fcf5ef2aSThomas Huth } \ 756fcf5ef2aSThomas Huth if (record) { \ 757fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 758fcf5ef2aSThomas Huth } \ 759fcf5ef2aSThomas Huth } 760fcf5ef2aSThomas Huth 761b6cb41b2SDavid Gibson /* 762b6cb41b2SDavid Gibson * VCMPNEZ - Vector compare not equal to zero 763fcf5ef2aSThomas Huth * suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word) 764fcf5ef2aSThomas Huth * element - element type to access from vector 765fcf5ef2aSThomas Huth */ 766fcf5ef2aSThomas Huth #define VCMPNE(suffix, element, etype, cmpzero) \ 767fcf5ef2aSThomas Huth VCMPNE_DO(suffix, element, etype, cmpzero, 0) \ 768fcf5ef2aSThomas Huth VCMPNE_DO(suffix##_dot, element, etype, cmpzero, 1) 769fcf5ef2aSThomas Huth VCMPNE(zb, u8, uint8_t, 1) 770fcf5ef2aSThomas Huth VCMPNE(zh, u16, uint16_t, 1) 771fcf5ef2aSThomas Huth VCMPNE(zw, u32, uint32_t, 1) 772fcf5ef2aSThomas Huth VCMPNE(b, u8, uint8_t, 0) 773fcf5ef2aSThomas Huth VCMPNE(h, u16, uint16_t, 0) 774fcf5ef2aSThomas Huth VCMPNE(w, u32, uint32_t, 0) 775fcf5ef2aSThomas Huth #undef VCMPNE_DO 776fcf5ef2aSThomas Huth #undef VCMPNE 777fcf5ef2aSThomas Huth 778fcf5ef2aSThomas Huth #define VCMPFP_DO(suffix, compare, order, record) \ 779fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 780fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 781fcf5ef2aSThomas Huth { \ 782fcf5ef2aSThomas Huth uint32_t ones = (uint32_t)-1; \ 783fcf5ef2aSThomas Huth uint32_t all = ones; \ 784fcf5ef2aSThomas Huth uint32_t none = 0; \ 785fcf5ef2aSThomas Huth int i; \ 786fcf5ef2aSThomas Huth \ 78705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 788fcf5ef2aSThomas Huth uint32_t result; \ 78905ee3e8aSMark Cave-Ayland int rel = float32_compare_quiet(a->f32[i], b->f32[i], \ 790fcf5ef2aSThomas Huth &env->vec_status); \ 791fcf5ef2aSThomas Huth if (rel == float_relation_unordered) { \ 792fcf5ef2aSThomas Huth result = 0; \ 793fcf5ef2aSThomas Huth } else if (rel compare order) { \ 794fcf5ef2aSThomas Huth result = ones; \ 795fcf5ef2aSThomas Huth } else { \ 796fcf5ef2aSThomas Huth result = 0; \ 797fcf5ef2aSThomas Huth } \ 798fcf5ef2aSThomas Huth r->u32[i] = result; \ 799fcf5ef2aSThomas Huth all &= result; \ 800fcf5ef2aSThomas Huth none |= result; \ 801fcf5ef2aSThomas Huth } \ 802fcf5ef2aSThomas Huth if (record) { \ 803fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 804fcf5ef2aSThomas Huth } \ 805fcf5ef2aSThomas Huth } 806fcf5ef2aSThomas Huth #define VCMPFP(suffix, compare, order) \ 807fcf5ef2aSThomas Huth VCMPFP_DO(suffix, compare, order, 0) \ 808fcf5ef2aSThomas Huth VCMPFP_DO(suffix##_dot, compare, order, 1) 809fcf5ef2aSThomas Huth VCMPFP(eqfp, ==, float_relation_equal) 810fcf5ef2aSThomas Huth VCMPFP(gefp, !=, float_relation_less) 811fcf5ef2aSThomas Huth VCMPFP(gtfp, ==, float_relation_greater) 812fcf5ef2aSThomas Huth #undef VCMPFP_DO 813fcf5ef2aSThomas Huth #undef VCMPFP 814fcf5ef2aSThomas Huth 815fcf5ef2aSThomas Huth static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r, 816fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b, int record) 817fcf5ef2aSThomas Huth { 818fcf5ef2aSThomas Huth int i; 819fcf5ef2aSThomas Huth int all_in = 0; 820fcf5ef2aSThomas Huth 82105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 82205ee3e8aSMark Cave-Ayland int le_rel = float32_compare_quiet(a->f32[i], b->f32[i], 82305ee3e8aSMark Cave-Ayland &env->vec_status); 824fcf5ef2aSThomas Huth if (le_rel == float_relation_unordered) { 825fcf5ef2aSThomas Huth r->u32[i] = 0xc0000000; 826fcf5ef2aSThomas Huth all_in = 1; 827fcf5ef2aSThomas Huth } else { 82805ee3e8aSMark Cave-Ayland float32 bneg = float32_chs(b->f32[i]); 82905ee3e8aSMark Cave-Ayland int ge_rel = float32_compare_quiet(a->f32[i], bneg, 83005ee3e8aSMark Cave-Ayland &env->vec_status); 831fcf5ef2aSThomas Huth int le = le_rel != float_relation_greater; 832fcf5ef2aSThomas Huth int ge = ge_rel != float_relation_less; 833fcf5ef2aSThomas Huth 834fcf5ef2aSThomas Huth r->u32[i] = ((!le) << 31) | ((!ge) << 30); 835fcf5ef2aSThomas Huth all_in |= (!le | !ge); 836fcf5ef2aSThomas Huth } 837fcf5ef2aSThomas Huth } 838fcf5ef2aSThomas Huth if (record) { 839fcf5ef2aSThomas Huth env->crf[6] = (all_in == 0) << 1; 840fcf5ef2aSThomas Huth } 841fcf5ef2aSThomas Huth } 842fcf5ef2aSThomas Huth 843fcf5ef2aSThomas Huth void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 844fcf5ef2aSThomas Huth { 845fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 0); 846fcf5ef2aSThomas Huth } 847fcf5ef2aSThomas Huth 848fcf5ef2aSThomas Huth void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 849fcf5ef2aSThomas Huth ppc_avr_t *b) 850fcf5ef2aSThomas Huth { 851fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 1); 852fcf5ef2aSThomas Huth } 853fcf5ef2aSThomas Huth 854fcf5ef2aSThomas Huth #define VCT(suffix, satcvt, element) \ 855fcf5ef2aSThomas Huth void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \ 856fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 857fcf5ef2aSThomas Huth { \ 858fcf5ef2aSThomas Huth int i; \ 859fcf5ef2aSThomas Huth int sat = 0; \ 860fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 861fcf5ef2aSThomas Huth \ 862fcf5ef2aSThomas Huth set_float_rounding_mode(float_round_to_zero, &s); \ 86305ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 86405ee3e8aSMark Cave-Ayland if (float32_is_any_nan(b->f32[i])) { \ 865fcf5ef2aSThomas Huth r->element[i] = 0; \ 866fcf5ef2aSThomas Huth } else { \ 86705ee3e8aSMark Cave-Ayland float64 t = float32_to_float64(b->f32[i], &s); \ 868fcf5ef2aSThomas Huth int64_t j; \ 869fcf5ef2aSThomas Huth \ 870fcf5ef2aSThomas Huth t = float64_scalbn(t, uim, &s); \ 871fcf5ef2aSThomas Huth j = float64_to_int64(t, &s); \ 872fcf5ef2aSThomas Huth r->element[i] = satcvt(j, &sat); \ 873fcf5ef2aSThomas Huth } \ 874fcf5ef2aSThomas Huth } \ 875fcf5ef2aSThomas Huth if (sat) { \ 8766175f5a0SRichard Henderson set_vscr_sat(env); \ 877fcf5ef2aSThomas Huth } \ 878fcf5ef2aSThomas Huth } 879fcf5ef2aSThomas Huth VCT(uxs, cvtsduw, u32) 880fcf5ef2aSThomas Huth VCT(sxs, cvtsdsw, s32) 881fcf5ef2aSThomas Huth #undef VCT 882fcf5ef2aSThomas Huth 883fcf5ef2aSThomas Huth target_ulong helper_vclzlsbb(ppc_avr_t *r) 884fcf5ef2aSThomas Huth { 885fcf5ef2aSThomas Huth target_ulong count = 0; 886fcf5ef2aSThomas Huth int i; 88760594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 88860594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 889fcf5ef2aSThomas Huth break; 890fcf5ef2aSThomas Huth } 891fcf5ef2aSThomas Huth count++; 892fcf5ef2aSThomas Huth } 893fcf5ef2aSThomas Huth return count; 894fcf5ef2aSThomas Huth } 895fcf5ef2aSThomas Huth 896fcf5ef2aSThomas Huth target_ulong helper_vctzlsbb(ppc_avr_t *r) 897fcf5ef2aSThomas Huth { 898fcf5ef2aSThomas Huth target_ulong count = 0; 899fcf5ef2aSThomas Huth int i; 900fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 90160594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 902fcf5ef2aSThomas Huth break; 903fcf5ef2aSThomas Huth } 904fcf5ef2aSThomas Huth count++; 905fcf5ef2aSThomas Huth } 906fcf5ef2aSThomas Huth return count; 907fcf5ef2aSThomas Huth } 908fcf5ef2aSThomas Huth 909fcf5ef2aSThomas Huth void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 910fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 911fcf5ef2aSThomas Huth { 912fcf5ef2aSThomas Huth int sat = 0; 913fcf5ef2aSThomas Huth int i; 914fcf5ef2aSThomas Huth 915fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 916fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 917fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 918fcf5ef2aSThomas Huth 919fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 920fcf5ef2aSThomas Huth } 921fcf5ef2aSThomas Huth 922fcf5ef2aSThomas Huth if (sat) { 9236175f5a0SRichard Henderson set_vscr_sat(env); 924fcf5ef2aSThomas Huth } 925fcf5ef2aSThomas Huth } 926fcf5ef2aSThomas Huth 927fcf5ef2aSThomas Huth void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 928fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 929fcf5ef2aSThomas Huth { 930fcf5ef2aSThomas Huth int sat = 0; 931fcf5ef2aSThomas Huth int i; 932fcf5ef2aSThomas Huth 933fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 934fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i] + 0x00004000; 935fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 936fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 937fcf5ef2aSThomas Huth } 938fcf5ef2aSThomas Huth 939fcf5ef2aSThomas Huth if (sat) { 9406175f5a0SRichard Henderson set_vscr_sat(env); 941fcf5ef2aSThomas Huth } 942fcf5ef2aSThomas Huth } 943fcf5ef2aSThomas Huth 944fcf5ef2aSThomas Huth void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 945fcf5ef2aSThomas Huth { 946fcf5ef2aSThomas Huth int i; 947fcf5ef2aSThomas Huth 948fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 949fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 950fcf5ef2aSThomas Huth r->s16[i] = (int16_t) (prod + c->s16[i]); 951fcf5ef2aSThomas Huth } 952fcf5ef2aSThomas Huth } 953fcf5ef2aSThomas Huth 954d81c2040SMark Cave-Ayland #define VMRG_DO(name, element, access, ofs) \ 955fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 956fcf5ef2aSThomas Huth { \ 957fcf5ef2aSThomas Huth ppc_avr_t result; \ 958d81c2040SMark Cave-Ayland int i, half = ARRAY_SIZE(r->element) / 2; \ 959fcf5ef2aSThomas Huth \ 960d81c2040SMark Cave-Ayland for (i = 0; i < half; i++) { \ 961d81c2040SMark Cave-Ayland result.access(i * 2 + 0) = a->access(i + ofs); \ 962d81c2040SMark Cave-Ayland result.access(i * 2 + 1) = b->access(i + ofs); \ 963fcf5ef2aSThomas Huth } \ 964fcf5ef2aSThomas Huth *r = result; \ 965fcf5ef2aSThomas Huth } 966d81c2040SMark Cave-Ayland 967d81c2040SMark Cave-Ayland #define VMRG(suffix, element, access) \ 968d81c2040SMark Cave-Ayland VMRG_DO(mrgl##suffix, element, access, half) \ 969d81c2040SMark Cave-Ayland VMRG_DO(mrgh##suffix, element, access, 0) 970d81c2040SMark Cave-Ayland VMRG(b, u8, VsrB) 971d81c2040SMark Cave-Ayland VMRG(h, u16, VsrH) 972d81c2040SMark Cave-Ayland VMRG(w, u32, VsrW) 973fcf5ef2aSThomas Huth #undef VMRG_DO 974fcf5ef2aSThomas Huth #undef VMRG 975fcf5ef2aSThomas Huth 976fcf5ef2aSThomas Huth void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 977fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 978fcf5ef2aSThomas Huth { 979fcf5ef2aSThomas Huth int32_t prod[16]; 980fcf5ef2aSThomas Huth int i; 981fcf5ef2aSThomas Huth 982fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s8); i++) { 983fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s8[i] * b->u8[i]; 984fcf5ef2aSThomas Huth } 985fcf5ef2aSThomas Huth 986fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 987fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] + 988fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 989fcf5ef2aSThomas Huth } 990fcf5ef2aSThomas Huth } 991fcf5ef2aSThomas Huth 992fcf5ef2aSThomas Huth void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 993fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 994fcf5ef2aSThomas Huth { 995fcf5ef2aSThomas Huth int32_t prod[8]; 996fcf5ef2aSThomas Huth int i; 997fcf5ef2aSThomas Huth 998fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 999fcf5ef2aSThomas Huth prod[i] = a->s16[i] * b->s16[i]; 1000fcf5ef2aSThomas Huth } 1001fcf5ef2aSThomas Huth 1002fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1003fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1004fcf5ef2aSThomas Huth } 1005fcf5ef2aSThomas Huth } 1006fcf5ef2aSThomas Huth 1007fcf5ef2aSThomas Huth void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1008fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1009fcf5ef2aSThomas Huth { 1010fcf5ef2aSThomas Huth int32_t prod[8]; 1011fcf5ef2aSThomas Huth int i; 1012fcf5ef2aSThomas Huth int sat = 0; 1013fcf5ef2aSThomas Huth 1014fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1015fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s16[i] * b->s16[i]; 1016fcf5ef2aSThomas Huth } 1017fcf5ef2aSThomas Huth 1018fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1019fcf5ef2aSThomas Huth int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1020fcf5ef2aSThomas Huth 1021fcf5ef2aSThomas Huth r->u32[i] = cvtsdsw(t, &sat); 1022fcf5ef2aSThomas Huth } 1023fcf5ef2aSThomas Huth 1024fcf5ef2aSThomas Huth if (sat) { 10256175f5a0SRichard Henderson set_vscr_sat(env); 1026fcf5ef2aSThomas Huth } 1027fcf5ef2aSThomas Huth } 1028fcf5ef2aSThomas Huth 1029fcf5ef2aSThomas Huth void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1030fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1031fcf5ef2aSThomas Huth { 1032fcf5ef2aSThomas Huth uint16_t prod[16]; 1033fcf5ef2aSThomas Huth int i; 1034fcf5ef2aSThomas Huth 1035fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1036fcf5ef2aSThomas Huth prod[i] = a->u8[i] * b->u8[i]; 1037fcf5ef2aSThomas Huth } 1038fcf5ef2aSThomas Huth 1039fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1040fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] + 1041fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1042fcf5ef2aSThomas Huth } 1043fcf5ef2aSThomas Huth } 1044fcf5ef2aSThomas Huth 1045fcf5ef2aSThomas Huth void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1046fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1047fcf5ef2aSThomas Huth { 1048fcf5ef2aSThomas Huth uint32_t prod[8]; 1049fcf5ef2aSThomas Huth int i; 1050fcf5ef2aSThomas Huth 1051fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1052fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1053fcf5ef2aSThomas Huth } 1054fcf5ef2aSThomas Huth 1055fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1056fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1057fcf5ef2aSThomas Huth } 1058fcf5ef2aSThomas Huth } 1059fcf5ef2aSThomas Huth 1060fcf5ef2aSThomas Huth void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1061fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1062fcf5ef2aSThomas Huth { 1063fcf5ef2aSThomas Huth uint32_t prod[8]; 1064fcf5ef2aSThomas Huth int i; 1065fcf5ef2aSThomas Huth int sat = 0; 1066fcf5ef2aSThomas Huth 1067fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1068fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1069fcf5ef2aSThomas Huth } 1070fcf5ef2aSThomas Huth 1071fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1072fcf5ef2aSThomas Huth uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1073fcf5ef2aSThomas Huth 1074fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1075fcf5ef2aSThomas Huth } 1076fcf5ef2aSThomas Huth 1077fcf5ef2aSThomas Huth if (sat) { 10786175f5a0SRichard Henderson set_vscr_sat(env); 1079fcf5ef2aSThomas Huth } 1080fcf5ef2aSThomas Huth } 1081fcf5ef2aSThomas Huth 10824fbc89edSMark Cave-Ayland #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast) \ 1083fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1084fcf5ef2aSThomas Huth { \ 1085fcf5ef2aSThomas Huth int i; \ 1086fcf5ef2aSThomas Huth \ 10874fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 10884fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i) * \ 10894fbc89edSMark Cave-Ayland (cast)b->mul_access(i); \ 1090fcf5ef2aSThomas Huth } \ 1091fcf5ef2aSThomas Huth } 10924fbc89edSMark Cave-Ayland 10934fbc89edSMark Cave-Ayland #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast) \ 10944fbc89edSMark Cave-Ayland void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 10954fbc89edSMark Cave-Ayland { \ 10964fbc89edSMark Cave-Ayland int i; \ 10974fbc89edSMark Cave-Ayland \ 10984fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 10994fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) * \ 11004fbc89edSMark Cave-Ayland (cast)b->mul_access(i + 1); \ 11014fbc89edSMark Cave-Ayland } \ 11024fbc89edSMark Cave-Ayland } 11034fbc89edSMark Cave-Ayland 11044fbc89edSMark Cave-Ayland #define VMUL(suffix, mul_element, mul_access, prod_access, cast) \ 11054fbc89edSMark Cave-Ayland VMUL_DO_EVN(mule##suffix, mul_element, mul_access, prod_access, cast) \ 11064fbc89edSMark Cave-Ayland VMUL_DO_ODD(mulo##suffix, mul_element, mul_access, prod_access, cast) 11074fbc89edSMark Cave-Ayland VMUL(sb, s8, VsrSB, VsrSH, int16_t) 11084fbc89edSMark Cave-Ayland VMUL(sh, s16, VsrSH, VsrSW, int32_t) 11094fbc89edSMark Cave-Ayland VMUL(sw, s32, VsrSW, VsrSD, int64_t) 11104fbc89edSMark Cave-Ayland VMUL(ub, u8, VsrB, VsrH, uint16_t) 11114fbc89edSMark Cave-Ayland VMUL(uh, u16, VsrH, VsrW, uint32_t) 11124fbc89edSMark Cave-Ayland VMUL(uw, u32, VsrW, VsrD, uint64_t) 11134fbc89edSMark Cave-Ayland #undef VMUL_DO_EVN 11144fbc89edSMark Cave-Ayland #undef VMUL_DO_ODD 1115fcf5ef2aSThomas Huth #undef VMUL 1116fcf5ef2aSThomas Huth 1117fcf5ef2aSThomas Huth void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1118fcf5ef2aSThomas Huth ppc_avr_t *c) 1119fcf5ef2aSThomas Huth { 1120fcf5ef2aSThomas Huth ppc_avr_t result; 1121fcf5ef2aSThomas Huth int i; 1122fcf5ef2aSThomas Huth 112360594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 112460594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1125fcf5ef2aSThomas Huth int index = s & 0xf; 1126fcf5ef2aSThomas Huth 1127fcf5ef2aSThomas Huth if (s & 0x10) { 112860594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1129fcf5ef2aSThomas Huth } else { 113060594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1131fcf5ef2aSThomas Huth } 1132fcf5ef2aSThomas Huth } 1133fcf5ef2aSThomas Huth *r = result; 1134fcf5ef2aSThomas Huth } 1135fcf5ef2aSThomas Huth 1136fcf5ef2aSThomas Huth void helper_vpermr(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1137fcf5ef2aSThomas Huth ppc_avr_t *c) 1138fcf5ef2aSThomas Huth { 1139fcf5ef2aSThomas Huth ppc_avr_t result; 1140fcf5ef2aSThomas Huth int i; 1141fcf5ef2aSThomas Huth 114260594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 114360594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1144fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1145fcf5ef2aSThomas Huth 1146fcf5ef2aSThomas Huth if (s & 0x10) { 114760594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1148fcf5ef2aSThomas Huth } else { 114960594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1150fcf5ef2aSThomas Huth } 1151fcf5ef2aSThomas Huth } 1152fcf5ef2aSThomas Huth *r = result; 1153fcf5ef2aSThomas Huth } 1154fcf5ef2aSThomas Huth 1155fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1156fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)]) 1157fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (i) 1158fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) != 0) 1159fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1)) 1160fcf5ef2aSThomas Huth #else 1161fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)]) 1162fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (1 - i) 1163fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) == 0) 1164fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) \ 1165fcf5ef2aSThomas Huth (extract64((avr)->u64[1 - i], 63 - index, 1)) 1166fcf5ef2aSThomas Huth #endif 1167fcf5ef2aSThomas Huth 1168fcf5ef2aSThomas Huth void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1169fcf5ef2aSThomas Huth { 1170fcf5ef2aSThomas Huth int i, j; 1171fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 1172fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1173fcf5ef2aSThomas Huth for (j = 0; j < 8; j++) { 1174fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, (i * 8) + j); 1175fcf5ef2aSThomas Huth if (index < 64 && EXTRACT_BIT(a, i, index)) { 1176fcf5ef2aSThomas Huth result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j); 1177fcf5ef2aSThomas Huth } 1178fcf5ef2aSThomas Huth } 1179fcf5ef2aSThomas Huth } 1180fcf5ef2aSThomas Huth *r = result; 1181fcf5ef2aSThomas Huth } 1182fcf5ef2aSThomas Huth 1183fcf5ef2aSThomas Huth void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1184fcf5ef2aSThomas Huth { 1185fcf5ef2aSThomas Huth int i; 1186fcf5ef2aSThomas Huth uint64_t perm = 0; 1187fcf5ef2aSThomas Huth 1188fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1189fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, i); 1190fcf5ef2aSThomas Huth 1191fcf5ef2aSThomas Huth if (index < 128) { 1192fcf5ef2aSThomas Huth uint64_t mask = (1ull << (63 - (index & 0x3F))); 1193fcf5ef2aSThomas Huth if (a->u64[VBPERMQ_DW(index)] & mask) { 1194fcf5ef2aSThomas Huth perm |= (0x8000 >> i); 1195fcf5ef2aSThomas Huth } 1196fcf5ef2aSThomas Huth } 1197fcf5ef2aSThomas Huth } 1198fcf5ef2aSThomas Huth 11993c385a93SMark Cave-Ayland r->VsrD(0) = perm; 12003c385a93SMark Cave-Ayland r->VsrD(1) = 0; 1201fcf5ef2aSThomas Huth } 1202fcf5ef2aSThomas Huth 1203fcf5ef2aSThomas Huth #undef VBPERMQ_INDEX 1204fcf5ef2aSThomas Huth #undef VBPERMQ_DW 1205fcf5ef2aSThomas Huth 1206fcf5ef2aSThomas Huth static const uint64_t VGBBD_MASKS[256] = { 1207fcf5ef2aSThomas Huth 0x0000000000000000ull, /* 00 */ 1208fcf5ef2aSThomas Huth 0x0000000000000080ull, /* 01 */ 1209fcf5ef2aSThomas Huth 0x0000000000008000ull, /* 02 */ 1210fcf5ef2aSThomas Huth 0x0000000000008080ull, /* 03 */ 1211fcf5ef2aSThomas Huth 0x0000000000800000ull, /* 04 */ 1212fcf5ef2aSThomas Huth 0x0000000000800080ull, /* 05 */ 1213fcf5ef2aSThomas Huth 0x0000000000808000ull, /* 06 */ 1214fcf5ef2aSThomas Huth 0x0000000000808080ull, /* 07 */ 1215fcf5ef2aSThomas Huth 0x0000000080000000ull, /* 08 */ 1216fcf5ef2aSThomas Huth 0x0000000080000080ull, /* 09 */ 1217fcf5ef2aSThomas Huth 0x0000000080008000ull, /* 0A */ 1218fcf5ef2aSThomas Huth 0x0000000080008080ull, /* 0B */ 1219fcf5ef2aSThomas Huth 0x0000000080800000ull, /* 0C */ 1220fcf5ef2aSThomas Huth 0x0000000080800080ull, /* 0D */ 1221fcf5ef2aSThomas Huth 0x0000000080808000ull, /* 0E */ 1222fcf5ef2aSThomas Huth 0x0000000080808080ull, /* 0F */ 1223fcf5ef2aSThomas Huth 0x0000008000000000ull, /* 10 */ 1224fcf5ef2aSThomas Huth 0x0000008000000080ull, /* 11 */ 1225fcf5ef2aSThomas Huth 0x0000008000008000ull, /* 12 */ 1226fcf5ef2aSThomas Huth 0x0000008000008080ull, /* 13 */ 1227fcf5ef2aSThomas Huth 0x0000008000800000ull, /* 14 */ 1228fcf5ef2aSThomas Huth 0x0000008000800080ull, /* 15 */ 1229fcf5ef2aSThomas Huth 0x0000008000808000ull, /* 16 */ 1230fcf5ef2aSThomas Huth 0x0000008000808080ull, /* 17 */ 1231fcf5ef2aSThomas Huth 0x0000008080000000ull, /* 18 */ 1232fcf5ef2aSThomas Huth 0x0000008080000080ull, /* 19 */ 1233fcf5ef2aSThomas Huth 0x0000008080008000ull, /* 1A */ 1234fcf5ef2aSThomas Huth 0x0000008080008080ull, /* 1B */ 1235fcf5ef2aSThomas Huth 0x0000008080800000ull, /* 1C */ 1236fcf5ef2aSThomas Huth 0x0000008080800080ull, /* 1D */ 1237fcf5ef2aSThomas Huth 0x0000008080808000ull, /* 1E */ 1238fcf5ef2aSThomas Huth 0x0000008080808080ull, /* 1F */ 1239fcf5ef2aSThomas Huth 0x0000800000000000ull, /* 20 */ 1240fcf5ef2aSThomas Huth 0x0000800000000080ull, /* 21 */ 1241fcf5ef2aSThomas Huth 0x0000800000008000ull, /* 22 */ 1242fcf5ef2aSThomas Huth 0x0000800000008080ull, /* 23 */ 1243fcf5ef2aSThomas Huth 0x0000800000800000ull, /* 24 */ 1244fcf5ef2aSThomas Huth 0x0000800000800080ull, /* 25 */ 1245fcf5ef2aSThomas Huth 0x0000800000808000ull, /* 26 */ 1246fcf5ef2aSThomas Huth 0x0000800000808080ull, /* 27 */ 1247fcf5ef2aSThomas Huth 0x0000800080000000ull, /* 28 */ 1248fcf5ef2aSThomas Huth 0x0000800080000080ull, /* 29 */ 1249fcf5ef2aSThomas Huth 0x0000800080008000ull, /* 2A */ 1250fcf5ef2aSThomas Huth 0x0000800080008080ull, /* 2B */ 1251fcf5ef2aSThomas Huth 0x0000800080800000ull, /* 2C */ 1252fcf5ef2aSThomas Huth 0x0000800080800080ull, /* 2D */ 1253fcf5ef2aSThomas Huth 0x0000800080808000ull, /* 2E */ 1254fcf5ef2aSThomas Huth 0x0000800080808080ull, /* 2F */ 1255fcf5ef2aSThomas Huth 0x0000808000000000ull, /* 30 */ 1256fcf5ef2aSThomas Huth 0x0000808000000080ull, /* 31 */ 1257fcf5ef2aSThomas Huth 0x0000808000008000ull, /* 32 */ 1258fcf5ef2aSThomas Huth 0x0000808000008080ull, /* 33 */ 1259fcf5ef2aSThomas Huth 0x0000808000800000ull, /* 34 */ 1260fcf5ef2aSThomas Huth 0x0000808000800080ull, /* 35 */ 1261fcf5ef2aSThomas Huth 0x0000808000808000ull, /* 36 */ 1262fcf5ef2aSThomas Huth 0x0000808000808080ull, /* 37 */ 1263fcf5ef2aSThomas Huth 0x0000808080000000ull, /* 38 */ 1264fcf5ef2aSThomas Huth 0x0000808080000080ull, /* 39 */ 1265fcf5ef2aSThomas Huth 0x0000808080008000ull, /* 3A */ 1266fcf5ef2aSThomas Huth 0x0000808080008080ull, /* 3B */ 1267fcf5ef2aSThomas Huth 0x0000808080800000ull, /* 3C */ 1268fcf5ef2aSThomas Huth 0x0000808080800080ull, /* 3D */ 1269fcf5ef2aSThomas Huth 0x0000808080808000ull, /* 3E */ 1270fcf5ef2aSThomas Huth 0x0000808080808080ull, /* 3F */ 1271fcf5ef2aSThomas Huth 0x0080000000000000ull, /* 40 */ 1272fcf5ef2aSThomas Huth 0x0080000000000080ull, /* 41 */ 1273fcf5ef2aSThomas Huth 0x0080000000008000ull, /* 42 */ 1274fcf5ef2aSThomas Huth 0x0080000000008080ull, /* 43 */ 1275fcf5ef2aSThomas Huth 0x0080000000800000ull, /* 44 */ 1276fcf5ef2aSThomas Huth 0x0080000000800080ull, /* 45 */ 1277fcf5ef2aSThomas Huth 0x0080000000808000ull, /* 46 */ 1278fcf5ef2aSThomas Huth 0x0080000000808080ull, /* 47 */ 1279fcf5ef2aSThomas Huth 0x0080000080000000ull, /* 48 */ 1280fcf5ef2aSThomas Huth 0x0080000080000080ull, /* 49 */ 1281fcf5ef2aSThomas Huth 0x0080000080008000ull, /* 4A */ 1282fcf5ef2aSThomas Huth 0x0080000080008080ull, /* 4B */ 1283fcf5ef2aSThomas Huth 0x0080000080800000ull, /* 4C */ 1284fcf5ef2aSThomas Huth 0x0080000080800080ull, /* 4D */ 1285fcf5ef2aSThomas Huth 0x0080000080808000ull, /* 4E */ 1286fcf5ef2aSThomas Huth 0x0080000080808080ull, /* 4F */ 1287fcf5ef2aSThomas Huth 0x0080008000000000ull, /* 50 */ 1288fcf5ef2aSThomas Huth 0x0080008000000080ull, /* 51 */ 1289fcf5ef2aSThomas Huth 0x0080008000008000ull, /* 52 */ 1290fcf5ef2aSThomas Huth 0x0080008000008080ull, /* 53 */ 1291fcf5ef2aSThomas Huth 0x0080008000800000ull, /* 54 */ 1292fcf5ef2aSThomas Huth 0x0080008000800080ull, /* 55 */ 1293fcf5ef2aSThomas Huth 0x0080008000808000ull, /* 56 */ 1294fcf5ef2aSThomas Huth 0x0080008000808080ull, /* 57 */ 1295fcf5ef2aSThomas Huth 0x0080008080000000ull, /* 58 */ 1296fcf5ef2aSThomas Huth 0x0080008080000080ull, /* 59 */ 1297fcf5ef2aSThomas Huth 0x0080008080008000ull, /* 5A */ 1298fcf5ef2aSThomas Huth 0x0080008080008080ull, /* 5B */ 1299fcf5ef2aSThomas Huth 0x0080008080800000ull, /* 5C */ 1300fcf5ef2aSThomas Huth 0x0080008080800080ull, /* 5D */ 1301fcf5ef2aSThomas Huth 0x0080008080808000ull, /* 5E */ 1302fcf5ef2aSThomas Huth 0x0080008080808080ull, /* 5F */ 1303fcf5ef2aSThomas Huth 0x0080800000000000ull, /* 60 */ 1304fcf5ef2aSThomas Huth 0x0080800000000080ull, /* 61 */ 1305fcf5ef2aSThomas Huth 0x0080800000008000ull, /* 62 */ 1306fcf5ef2aSThomas Huth 0x0080800000008080ull, /* 63 */ 1307fcf5ef2aSThomas Huth 0x0080800000800000ull, /* 64 */ 1308fcf5ef2aSThomas Huth 0x0080800000800080ull, /* 65 */ 1309fcf5ef2aSThomas Huth 0x0080800000808000ull, /* 66 */ 1310fcf5ef2aSThomas Huth 0x0080800000808080ull, /* 67 */ 1311fcf5ef2aSThomas Huth 0x0080800080000000ull, /* 68 */ 1312fcf5ef2aSThomas Huth 0x0080800080000080ull, /* 69 */ 1313fcf5ef2aSThomas Huth 0x0080800080008000ull, /* 6A */ 1314fcf5ef2aSThomas Huth 0x0080800080008080ull, /* 6B */ 1315fcf5ef2aSThomas Huth 0x0080800080800000ull, /* 6C */ 1316fcf5ef2aSThomas Huth 0x0080800080800080ull, /* 6D */ 1317fcf5ef2aSThomas Huth 0x0080800080808000ull, /* 6E */ 1318fcf5ef2aSThomas Huth 0x0080800080808080ull, /* 6F */ 1319fcf5ef2aSThomas Huth 0x0080808000000000ull, /* 70 */ 1320fcf5ef2aSThomas Huth 0x0080808000000080ull, /* 71 */ 1321fcf5ef2aSThomas Huth 0x0080808000008000ull, /* 72 */ 1322fcf5ef2aSThomas Huth 0x0080808000008080ull, /* 73 */ 1323fcf5ef2aSThomas Huth 0x0080808000800000ull, /* 74 */ 1324fcf5ef2aSThomas Huth 0x0080808000800080ull, /* 75 */ 1325fcf5ef2aSThomas Huth 0x0080808000808000ull, /* 76 */ 1326fcf5ef2aSThomas Huth 0x0080808000808080ull, /* 77 */ 1327fcf5ef2aSThomas Huth 0x0080808080000000ull, /* 78 */ 1328fcf5ef2aSThomas Huth 0x0080808080000080ull, /* 79 */ 1329fcf5ef2aSThomas Huth 0x0080808080008000ull, /* 7A */ 1330fcf5ef2aSThomas Huth 0x0080808080008080ull, /* 7B */ 1331fcf5ef2aSThomas Huth 0x0080808080800000ull, /* 7C */ 1332fcf5ef2aSThomas Huth 0x0080808080800080ull, /* 7D */ 1333fcf5ef2aSThomas Huth 0x0080808080808000ull, /* 7E */ 1334fcf5ef2aSThomas Huth 0x0080808080808080ull, /* 7F */ 1335fcf5ef2aSThomas Huth 0x8000000000000000ull, /* 80 */ 1336fcf5ef2aSThomas Huth 0x8000000000000080ull, /* 81 */ 1337fcf5ef2aSThomas Huth 0x8000000000008000ull, /* 82 */ 1338fcf5ef2aSThomas Huth 0x8000000000008080ull, /* 83 */ 1339fcf5ef2aSThomas Huth 0x8000000000800000ull, /* 84 */ 1340fcf5ef2aSThomas Huth 0x8000000000800080ull, /* 85 */ 1341fcf5ef2aSThomas Huth 0x8000000000808000ull, /* 86 */ 1342fcf5ef2aSThomas Huth 0x8000000000808080ull, /* 87 */ 1343fcf5ef2aSThomas Huth 0x8000000080000000ull, /* 88 */ 1344fcf5ef2aSThomas Huth 0x8000000080000080ull, /* 89 */ 1345fcf5ef2aSThomas Huth 0x8000000080008000ull, /* 8A */ 1346fcf5ef2aSThomas Huth 0x8000000080008080ull, /* 8B */ 1347fcf5ef2aSThomas Huth 0x8000000080800000ull, /* 8C */ 1348fcf5ef2aSThomas Huth 0x8000000080800080ull, /* 8D */ 1349fcf5ef2aSThomas Huth 0x8000000080808000ull, /* 8E */ 1350fcf5ef2aSThomas Huth 0x8000000080808080ull, /* 8F */ 1351fcf5ef2aSThomas Huth 0x8000008000000000ull, /* 90 */ 1352fcf5ef2aSThomas Huth 0x8000008000000080ull, /* 91 */ 1353fcf5ef2aSThomas Huth 0x8000008000008000ull, /* 92 */ 1354fcf5ef2aSThomas Huth 0x8000008000008080ull, /* 93 */ 1355fcf5ef2aSThomas Huth 0x8000008000800000ull, /* 94 */ 1356fcf5ef2aSThomas Huth 0x8000008000800080ull, /* 95 */ 1357fcf5ef2aSThomas Huth 0x8000008000808000ull, /* 96 */ 1358fcf5ef2aSThomas Huth 0x8000008000808080ull, /* 97 */ 1359fcf5ef2aSThomas Huth 0x8000008080000000ull, /* 98 */ 1360fcf5ef2aSThomas Huth 0x8000008080000080ull, /* 99 */ 1361fcf5ef2aSThomas Huth 0x8000008080008000ull, /* 9A */ 1362fcf5ef2aSThomas Huth 0x8000008080008080ull, /* 9B */ 1363fcf5ef2aSThomas Huth 0x8000008080800000ull, /* 9C */ 1364fcf5ef2aSThomas Huth 0x8000008080800080ull, /* 9D */ 1365fcf5ef2aSThomas Huth 0x8000008080808000ull, /* 9E */ 1366fcf5ef2aSThomas Huth 0x8000008080808080ull, /* 9F */ 1367fcf5ef2aSThomas Huth 0x8000800000000000ull, /* A0 */ 1368fcf5ef2aSThomas Huth 0x8000800000000080ull, /* A1 */ 1369fcf5ef2aSThomas Huth 0x8000800000008000ull, /* A2 */ 1370fcf5ef2aSThomas Huth 0x8000800000008080ull, /* A3 */ 1371fcf5ef2aSThomas Huth 0x8000800000800000ull, /* A4 */ 1372fcf5ef2aSThomas Huth 0x8000800000800080ull, /* A5 */ 1373fcf5ef2aSThomas Huth 0x8000800000808000ull, /* A6 */ 1374fcf5ef2aSThomas Huth 0x8000800000808080ull, /* A7 */ 1375fcf5ef2aSThomas Huth 0x8000800080000000ull, /* A8 */ 1376fcf5ef2aSThomas Huth 0x8000800080000080ull, /* A9 */ 1377fcf5ef2aSThomas Huth 0x8000800080008000ull, /* AA */ 1378fcf5ef2aSThomas Huth 0x8000800080008080ull, /* AB */ 1379fcf5ef2aSThomas Huth 0x8000800080800000ull, /* AC */ 1380fcf5ef2aSThomas Huth 0x8000800080800080ull, /* AD */ 1381fcf5ef2aSThomas Huth 0x8000800080808000ull, /* AE */ 1382fcf5ef2aSThomas Huth 0x8000800080808080ull, /* AF */ 1383fcf5ef2aSThomas Huth 0x8000808000000000ull, /* B0 */ 1384fcf5ef2aSThomas Huth 0x8000808000000080ull, /* B1 */ 1385fcf5ef2aSThomas Huth 0x8000808000008000ull, /* B2 */ 1386fcf5ef2aSThomas Huth 0x8000808000008080ull, /* B3 */ 1387fcf5ef2aSThomas Huth 0x8000808000800000ull, /* B4 */ 1388fcf5ef2aSThomas Huth 0x8000808000800080ull, /* B5 */ 1389fcf5ef2aSThomas Huth 0x8000808000808000ull, /* B6 */ 1390fcf5ef2aSThomas Huth 0x8000808000808080ull, /* B7 */ 1391fcf5ef2aSThomas Huth 0x8000808080000000ull, /* B8 */ 1392fcf5ef2aSThomas Huth 0x8000808080000080ull, /* B9 */ 1393fcf5ef2aSThomas Huth 0x8000808080008000ull, /* BA */ 1394fcf5ef2aSThomas Huth 0x8000808080008080ull, /* BB */ 1395fcf5ef2aSThomas Huth 0x8000808080800000ull, /* BC */ 1396fcf5ef2aSThomas Huth 0x8000808080800080ull, /* BD */ 1397fcf5ef2aSThomas Huth 0x8000808080808000ull, /* BE */ 1398fcf5ef2aSThomas Huth 0x8000808080808080ull, /* BF */ 1399fcf5ef2aSThomas Huth 0x8080000000000000ull, /* C0 */ 1400fcf5ef2aSThomas Huth 0x8080000000000080ull, /* C1 */ 1401fcf5ef2aSThomas Huth 0x8080000000008000ull, /* C2 */ 1402fcf5ef2aSThomas Huth 0x8080000000008080ull, /* C3 */ 1403fcf5ef2aSThomas Huth 0x8080000000800000ull, /* C4 */ 1404fcf5ef2aSThomas Huth 0x8080000000800080ull, /* C5 */ 1405fcf5ef2aSThomas Huth 0x8080000000808000ull, /* C6 */ 1406fcf5ef2aSThomas Huth 0x8080000000808080ull, /* C7 */ 1407fcf5ef2aSThomas Huth 0x8080000080000000ull, /* C8 */ 1408fcf5ef2aSThomas Huth 0x8080000080000080ull, /* C9 */ 1409fcf5ef2aSThomas Huth 0x8080000080008000ull, /* CA */ 1410fcf5ef2aSThomas Huth 0x8080000080008080ull, /* CB */ 1411fcf5ef2aSThomas Huth 0x8080000080800000ull, /* CC */ 1412fcf5ef2aSThomas Huth 0x8080000080800080ull, /* CD */ 1413fcf5ef2aSThomas Huth 0x8080000080808000ull, /* CE */ 1414fcf5ef2aSThomas Huth 0x8080000080808080ull, /* CF */ 1415fcf5ef2aSThomas Huth 0x8080008000000000ull, /* D0 */ 1416fcf5ef2aSThomas Huth 0x8080008000000080ull, /* D1 */ 1417fcf5ef2aSThomas Huth 0x8080008000008000ull, /* D2 */ 1418fcf5ef2aSThomas Huth 0x8080008000008080ull, /* D3 */ 1419fcf5ef2aSThomas Huth 0x8080008000800000ull, /* D4 */ 1420fcf5ef2aSThomas Huth 0x8080008000800080ull, /* D5 */ 1421fcf5ef2aSThomas Huth 0x8080008000808000ull, /* D6 */ 1422fcf5ef2aSThomas Huth 0x8080008000808080ull, /* D7 */ 1423fcf5ef2aSThomas Huth 0x8080008080000000ull, /* D8 */ 1424fcf5ef2aSThomas Huth 0x8080008080000080ull, /* D9 */ 1425fcf5ef2aSThomas Huth 0x8080008080008000ull, /* DA */ 1426fcf5ef2aSThomas Huth 0x8080008080008080ull, /* DB */ 1427fcf5ef2aSThomas Huth 0x8080008080800000ull, /* DC */ 1428fcf5ef2aSThomas Huth 0x8080008080800080ull, /* DD */ 1429fcf5ef2aSThomas Huth 0x8080008080808000ull, /* DE */ 1430fcf5ef2aSThomas Huth 0x8080008080808080ull, /* DF */ 1431fcf5ef2aSThomas Huth 0x8080800000000000ull, /* E0 */ 1432fcf5ef2aSThomas Huth 0x8080800000000080ull, /* E1 */ 1433fcf5ef2aSThomas Huth 0x8080800000008000ull, /* E2 */ 1434fcf5ef2aSThomas Huth 0x8080800000008080ull, /* E3 */ 1435fcf5ef2aSThomas Huth 0x8080800000800000ull, /* E4 */ 1436fcf5ef2aSThomas Huth 0x8080800000800080ull, /* E5 */ 1437fcf5ef2aSThomas Huth 0x8080800000808000ull, /* E6 */ 1438fcf5ef2aSThomas Huth 0x8080800000808080ull, /* E7 */ 1439fcf5ef2aSThomas Huth 0x8080800080000000ull, /* E8 */ 1440fcf5ef2aSThomas Huth 0x8080800080000080ull, /* E9 */ 1441fcf5ef2aSThomas Huth 0x8080800080008000ull, /* EA */ 1442fcf5ef2aSThomas Huth 0x8080800080008080ull, /* EB */ 1443fcf5ef2aSThomas Huth 0x8080800080800000ull, /* EC */ 1444fcf5ef2aSThomas Huth 0x8080800080800080ull, /* ED */ 1445fcf5ef2aSThomas Huth 0x8080800080808000ull, /* EE */ 1446fcf5ef2aSThomas Huth 0x8080800080808080ull, /* EF */ 1447fcf5ef2aSThomas Huth 0x8080808000000000ull, /* F0 */ 1448fcf5ef2aSThomas Huth 0x8080808000000080ull, /* F1 */ 1449fcf5ef2aSThomas Huth 0x8080808000008000ull, /* F2 */ 1450fcf5ef2aSThomas Huth 0x8080808000008080ull, /* F3 */ 1451fcf5ef2aSThomas Huth 0x8080808000800000ull, /* F4 */ 1452fcf5ef2aSThomas Huth 0x8080808000800080ull, /* F5 */ 1453fcf5ef2aSThomas Huth 0x8080808000808000ull, /* F6 */ 1454fcf5ef2aSThomas Huth 0x8080808000808080ull, /* F7 */ 1455fcf5ef2aSThomas Huth 0x8080808080000000ull, /* F8 */ 1456fcf5ef2aSThomas Huth 0x8080808080000080ull, /* F9 */ 1457fcf5ef2aSThomas Huth 0x8080808080008000ull, /* FA */ 1458fcf5ef2aSThomas Huth 0x8080808080008080ull, /* FB */ 1459fcf5ef2aSThomas Huth 0x8080808080800000ull, /* FC */ 1460fcf5ef2aSThomas Huth 0x8080808080800080ull, /* FD */ 1461fcf5ef2aSThomas Huth 0x8080808080808000ull, /* FE */ 1462fcf5ef2aSThomas Huth 0x8080808080808080ull, /* FF */ 1463fcf5ef2aSThomas Huth }; 1464fcf5ef2aSThomas Huth 1465fcf5ef2aSThomas Huth void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b) 1466fcf5ef2aSThomas Huth { 1467fcf5ef2aSThomas Huth int i; 1468fcf5ef2aSThomas Huth uint64_t t[2] = { 0, 0 }; 1469fcf5ef2aSThomas Huth 1470fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1471fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1472fcf5ef2aSThomas Huth t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7); 1473fcf5ef2aSThomas Huth #else 1474fcf5ef2aSThomas Huth t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (7 - (i & 7)); 1475fcf5ef2aSThomas Huth #endif 1476fcf5ef2aSThomas Huth } 1477fcf5ef2aSThomas Huth 1478fcf5ef2aSThomas Huth r->u64[0] = t[0]; 1479fcf5ef2aSThomas Huth r->u64[1] = t[1]; 1480fcf5ef2aSThomas Huth } 1481fcf5ef2aSThomas Huth 1482fcf5ef2aSThomas Huth #define PMSUM(name, srcfld, trgfld, trgtyp) \ 1483fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1484fcf5ef2aSThomas Huth { \ 1485fcf5ef2aSThomas Huth int i, j; \ 1486fcf5ef2aSThomas Huth trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])]; \ 1487fcf5ef2aSThomas Huth \ 1488fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, srcfld) { \ 1489fcf5ef2aSThomas Huth prod[i] = 0; \ 1490fcf5ef2aSThomas Huth for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \ 1491fcf5ef2aSThomas Huth if (a->srcfld[i] & (1ull << j)) { \ 1492fcf5ef2aSThomas Huth prod[i] ^= ((trgtyp)b->srcfld[i] << j); \ 1493fcf5ef2aSThomas Huth } \ 1494fcf5ef2aSThomas Huth } \ 1495fcf5ef2aSThomas Huth } \ 1496fcf5ef2aSThomas Huth \ 1497fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, trgfld) { \ 1498fcf5ef2aSThomas Huth r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1]; \ 1499fcf5ef2aSThomas Huth } \ 1500fcf5ef2aSThomas Huth } 1501fcf5ef2aSThomas Huth 1502fcf5ef2aSThomas Huth PMSUM(vpmsumb, u8, u16, uint16_t) 1503fcf5ef2aSThomas Huth PMSUM(vpmsumh, u16, u32, uint32_t) 1504fcf5ef2aSThomas Huth PMSUM(vpmsumw, u32, u64, uint64_t) 1505fcf5ef2aSThomas Huth 1506fcf5ef2aSThomas Huth void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1507fcf5ef2aSThomas Huth { 1508fcf5ef2aSThomas Huth 1509fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1510fcf5ef2aSThomas Huth int i, j; 1511fcf5ef2aSThomas Huth __uint128_t prod[2]; 1512fcf5ef2aSThomas Huth 1513fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1514fcf5ef2aSThomas Huth prod[i] = 0; 1515fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1516fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1517fcf5ef2aSThomas Huth prod[i] ^= (((__uint128_t)b->u64[i]) << j); 1518fcf5ef2aSThomas Huth } 1519fcf5ef2aSThomas Huth } 1520fcf5ef2aSThomas Huth } 1521fcf5ef2aSThomas Huth 1522fcf5ef2aSThomas Huth r->u128 = prod[0] ^ prod[1]; 1523fcf5ef2aSThomas Huth 1524fcf5ef2aSThomas Huth #else 1525fcf5ef2aSThomas Huth int i, j; 1526fcf5ef2aSThomas Huth ppc_avr_t prod[2]; 1527fcf5ef2aSThomas Huth 1528fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 15293c385a93SMark Cave-Ayland prod[i].VsrD(1) = prod[i].VsrD(0) = 0; 1530fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1531fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1532fcf5ef2aSThomas Huth ppc_avr_t bshift; 1533fcf5ef2aSThomas Huth if (j == 0) { 15343c385a93SMark Cave-Ayland bshift.VsrD(0) = 0; 15353c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i]; 1536fcf5ef2aSThomas Huth } else { 15373c385a93SMark Cave-Ayland bshift.VsrD(0) = b->u64[i] >> (64 - j); 15383c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i] << j; 1539fcf5ef2aSThomas Huth } 15403c385a93SMark Cave-Ayland prod[i].VsrD(1) ^= bshift.VsrD(1); 15413c385a93SMark Cave-Ayland prod[i].VsrD(0) ^= bshift.VsrD(0); 1542fcf5ef2aSThomas Huth } 1543fcf5ef2aSThomas Huth } 1544fcf5ef2aSThomas Huth } 1545fcf5ef2aSThomas Huth 15463c385a93SMark Cave-Ayland r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1); 15473c385a93SMark Cave-Ayland r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0); 1548fcf5ef2aSThomas Huth #endif 1549fcf5ef2aSThomas Huth } 1550fcf5ef2aSThomas Huth 1551fcf5ef2aSThomas Huth 1552fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1553fcf5ef2aSThomas Huth #define PKBIG 1 1554fcf5ef2aSThomas Huth #else 1555fcf5ef2aSThomas Huth #define PKBIG 0 1556fcf5ef2aSThomas Huth #endif 1557fcf5ef2aSThomas Huth void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1558fcf5ef2aSThomas Huth { 1559fcf5ef2aSThomas Huth int i, j; 1560fcf5ef2aSThomas Huth ppc_avr_t result; 1561fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1562fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { a, b }; 1563fcf5ef2aSThomas Huth #else 1564fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { b, a }; 1565fcf5ef2aSThomas Huth #endif 1566fcf5ef2aSThomas Huth 1567fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1568fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(j, u32) { 1569fcf5ef2aSThomas Huth uint32_t e = x[i]->u32[j]; 1570fcf5ef2aSThomas Huth 1571fcf5ef2aSThomas Huth result.u16[4 * i + j] = (((e >> 9) & 0xfc00) | 1572fcf5ef2aSThomas Huth ((e >> 6) & 0x3e0) | 1573fcf5ef2aSThomas Huth ((e >> 3) & 0x1f)); 1574fcf5ef2aSThomas Huth } 1575fcf5ef2aSThomas Huth } 1576fcf5ef2aSThomas Huth *r = result; 1577fcf5ef2aSThomas Huth } 1578fcf5ef2aSThomas Huth 1579fcf5ef2aSThomas Huth #define VPK(suffix, from, to, cvt, dosat) \ 1580fcf5ef2aSThomas Huth void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1581fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 1582fcf5ef2aSThomas Huth { \ 1583fcf5ef2aSThomas Huth int i; \ 1584fcf5ef2aSThomas Huth int sat = 0; \ 1585fcf5ef2aSThomas Huth ppc_avr_t result; \ 1586fcf5ef2aSThomas Huth ppc_avr_t *a0 = PKBIG ? a : b; \ 1587fcf5ef2aSThomas Huth ppc_avr_t *a1 = PKBIG ? b : a; \ 1588fcf5ef2aSThomas Huth \ 1589fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, from) { \ 1590fcf5ef2aSThomas Huth result.to[i] = cvt(a0->from[i], &sat); \ 1591fcf5ef2aSThomas Huth result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\ 1592fcf5ef2aSThomas Huth } \ 1593fcf5ef2aSThomas Huth *r = result; \ 1594fcf5ef2aSThomas Huth if (dosat && sat) { \ 15956175f5a0SRichard Henderson set_vscr_sat(env); \ 1596fcf5ef2aSThomas Huth } \ 1597fcf5ef2aSThomas Huth } 1598fcf5ef2aSThomas Huth #define I(x, y) (x) 1599fcf5ef2aSThomas Huth VPK(shss, s16, s8, cvtshsb, 1) 1600fcf5ef2aSThomas Huth VPK(shus, s16, u8, cvtshub, 1) 1601fcf5ef2aSThomas Huth VPK(swss, s32, s16, cvtswsh, 1) 1602fcf5ef2aSThomas Huth VPK(swus, s32, u16, cvtswuh, 1) 1603fcf5ef2aSThomas Huth VPK(sdss, s64, s32, cvtsdsw, 1) 1604fcf5ef2aSThomas Huth VPK(sdus, s64, u32, cvtsduw, 1) 1605fcf5ef2aSThomas Huth VPK(uhus, u16, u8, cvtuhub, 1) 1606fcf5ef2aSThomas Huth VPK(uwus, u32, u16, cvtuwuh, 1) 1607fcf5ef2aSThomas Huth VPK(udus, u64, u32, cvtuduw, 1) 1608fcf5ef2aSThomas Huth VPK(uhum, u16, u8, I, 0) 1609fcf5ef2aSThomas Huth VPK(uwum, u32, u16, I, 0) 1610fcf5ef2aSThomas Huth VPK(udum, u64, u32, I, 0) 1611fcf5ef2aSThomas Huth #undef I 1612fcf5ef2aSThomas Huth #undef VPK 1613fcf5ef2aSThomas Huth #undef PKBIG 1614fcf5ef2aSThomas Huth 1615fcf5ef2aSThomas Huth void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1616fcf5ef2aSThomas Huth { 1617fcf5ef2aSThomas Huth int i; 1618fcf5ef2aSThomas Huth 161905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 162005ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status); 1621fcf5ef2aSThomas Huth } 1622fcf5ef2aSThomas Huth } 1623fcf5ef2aSThomas Huth 1624fcf5ef2aSThomas Huth #define VRFI(suffix, rounding) \ 1625fcf5ef2aSThomas Huth void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1626fcf5ef2aSThomas Huth ppc_avr_t *b) \ 1627fcf5ef2aSThomas Huth { \ 1628fcf5ef2aSThomas Huth int i; \ 1629fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 1630fcf5ef2aSThomas Huth \ 1631fcf5ef2aSThomas Huth set_float_rounding_mode(rounding, &s); \ 163205ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 163305ee3e8aSMark Cave-Ayland r->f32[i] = float32_round_to_int (b->f32[i], &s); \ 1634fcf5ef2aSThomas Huth } \ 1635fcf5ef2aSThomas Huth } 1636fcf5ef2aSThomas Huth VRFI(n, float_round_nearest_even) 1637fcf5ef2aSThomas Huth VRFI(m, float_round_down) 1638fcf5ef2aSThomas Huth VRFI(p, float_round_up) 1639fcf5ef2aSThomas Huth VRFI(z, float_round_to_zero) 1640fcf5ef2aSThomas Huth #undef VRFI 1641fcf5ef2aSThomas Huth 1642fcf5ef2aSThomas Huth #define VROTATE(suffix, element, mask) \ 1643fcf5ef2aSThomas Huth void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1644fcf5ef2aSThomas Huth { \ 1645fcf5ef2aSThomas Huth int i; \ 1646fcf5ef2aSThomas Huth \ 1647fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1648fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1649fcf5ef2aSThomas Huth r->element[i] = (a->element[i] << shift) | \ 1650fcf5ef2aSThomas Huth (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \ 1651fcf5ef2aSThomas Huth } \ 1652fcf5ef2aSThomas Huth } 1653fcf5ef2aSThomas Huth VROTATE(b, u8, 0x7) 1654fcf5ef2aSThomas Huth VROTATE(h, u16, 0xF) 1655fcf5ef2aSThomas Huth VROTATE(w, u32, 0x1F) 1656fcf5ef2aSThomas Huth VROTATE(d, u64, 0x3F) 1657fcf5ef2aSThomas Huth #undef VROTATE 1658fcf5ef2aSThomas Huth 1659fcf5ef2aSThomas Huth void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1660fcf5ef2aSThomas Huth { 1661fcf5ef2aSThomas Huth int i; 1662fcf5ef2aSThomas Huth 166305ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 166405ee3e8aSMark Cave-Ayland float32 t = float32_sqrt(b->f32[i], &env->vec_status); 1665fcf5ef2aSThomas Huth 166605ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, t, &env->vec_status); 1667fcf5ef2aSThomas Huth } 1668fcf5ef2aSThomas Huth } 1669fcf5ef2aSThomas Huth 1670fcf5ef2aSThomas Huth #define VRLMI(name, size, element, insert) \ 1671fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1672fcf5ef2aSThomas Huth { \ 1673fcf5ef2aSThomas Huth int i; \ 1674fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1675fcf5ef2aSThomas Huth uint##size##_t src1 = a->element[i]; \ 1676fcf5ef2aSThomas Huth uint##size##_t src2 = b->element[i]; \ 1677fcf5ef2aSThomas Huth uint##size##_t src3 = r->element[i]; \ 1678fcf5ef2aSThomas Huth uint##size##_t begin, end, shift, mask, rot_val; \ 1679fcf5ef2aSThomas Huth \ 1680fcf5ef2aSThomas Huth shift = extract##size(src2, 0, 6); \ 1681fcf5ef2aSThomas Huth end = extract##size(src2, 8, 6); \ 1682fcf5ef2aSThomas Huth begin = extract##size(src2, 16, 6); \ 1683fcf5ef2aSThomas Huth rot_val = rol##size(src1, shift); \ 1684fcf5ef2aSThomas Huth mask = mask_u##size(begin, end); \ 1685fcf5ef2aSThomas Huth if (insert) { \ 1686fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask) | (src3 & ~mask); \ 1687fcf5ef2aSThomas Huth } else { \ 1688fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask); \ 1689fcf5ef2aSThomas Huth } \ 1690fcf5ef2aSThomas Huth } \ 1691fcf5ef2aSThomas Huth } 1692fcf5ef2aSThomas Huth 1693fcf5ef2aSThomas Huth VRLMI(vrldmi, 64, u64, 1); 1694fcf5ef2aSThomas Huth VRLMI(vrlwmi, 32, u32, 1); 1695fcf5ef2aSThomas Huth VRLMI(vrldnm, 64, u64, 0); 1696fcf5ef2aSThomas Huth VRLMI(vrlwnm, 32, u32, 0); 1697fcf5ef2aSThomas Huth 1698fcf5ef2aSThomas Huth void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1699fcf5ef2aSThomas Huth ppc_avr_t *c) 1700fcf5ef2aSThomas Huth { 1701fcf5ef2aSThomas Huth r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]); 1702fcf5ef2aSThomas Huth r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]); 1703fcf5ef2aSThomas Huth } 1704fcf5ef2aSThomas Huth 1705fcf5ef2aSThomas Huth void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1706fcf5ef2aSThomas Huth { 1707fcf5ef2aSThomas Huth int i; 1708fcf5ef2aSThomas Huth 170905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 171005ee3e8aSMark Cave-Ayland r->f32[i] = float32_exp2(b->f32[i], &env->vec_status); 1711fcf5ef2aSThomas Huth } 1712fcf5ef2aSThomas Huth } 1713fcf5ef2aSThomas Huth 1714fcf5ef2aSThomas Huth void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1715fcf5ef2aSThomas Huth { 1716fcf5ef2aSThomas Huth int i; 1717fcf5ef2aSThomas Huth 171805ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 171905ee3e8aSMark Cave-Ayland r->f32[i] = float32_log2(b->f32[i], &env->vec_status); 1720fcf5ef2aSThomas Huth } 1721fcf5ef2aSThomas Huth } 1722fcf5ef2aSThomas Huth 172360caf221SAvinesh Kumar #if defined(HOST_WORDS_BIGENDIAN) 172460caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 172560caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 172660caf221SAvinesh Kumar { \ 172760caf221SAvinesh Kumar int index; \ 172860caf221SAvinesh Kumar if (left) { \ 172960caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 173060caf221SAvinesh Kumar } else { \ 173160caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 173260caf221SAvinesh Kumar } \ 173360caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 173460caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 173560caf221SAvinesh Kumar } 173660caf221SAvinesh Kumar #else 173760caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 173860caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 173960caf221SAvinesh Kumar { \ 174060caf221SAvinesh Kumar int index; \ 174160caf221SAvinesh Kumar if (left) { \ 174260caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 174360caf221SAvinesh Kumar } else { \ 174460caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 174560caf221SAvinesh Kumar } \ 174660caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 174760caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 174860caf221SAvinesh Kumar } 174960caf221SAvinesh Kumar #endif 175060caf221SAvinesh Kumar 175160caf221SAvinesh Kumar VEXTU_X_DO(vextublx, 8, 1) 175260caf221SAvinesh Kumar VEXTU_X_DO(vextuhlx, 16, 1) 175360caf221SAvinesh Kumar VEXTU_X_DO(vextuwlx, 32, 1) 175460caf221SAvinesh Kumar VEXTU_X_DO(vextubrx, 8, 0) 175560caf221SAvinesh Kumar VEXTU_X_DO(vextuhrx, 16, 0) 175660caf221SAvinesh Kumar VEXTU_X_DO(vextuwrx, 32, 0) 175760caf221SAvinesh Kumar #undef VEXTU_X_DO 175860caf221SAvinesh Kumar 1759b6cb41b2SDavid Gibson /* 1760b6cb41b2SDavid Gibson * The specification says that the results are undefined if all of the 1761b6cb41b2SDavid Gibson * shift counts are not identical. We check to make sure that they 1762b6cb41b2SDavid Gibson * are to conform to what real hardware appears to do. 1763b6cb41b2SDavid Gibson */ 1764fcf5ef2aSThomas Huth #define VSHIFT(suffix, leftp) \ 1765fcf5ef2aSThomas Huth void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1766fcf5ef2aSThomas Huth { \ 17673c385a93SMark Cave-Ayland int shift = b->VsrB(15) & 0x7; \ 1768fcf5ef2aSThomas Huth int doit = 1; \ 1769fcf5ef2aSThomas Huth int i; \ 1770fcf5ef2aSThomas Huth \ 1771fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { \ 1772fcf5ef2aSThomas Huth doit = doit && ((b->u8[i] & 0x7) == shift); \ 1773fcf5ef2aSThomas Huth } \ 1774fcf5ef2aSThomas Huth if (doit) { \ 1775fcf5ef2aSThomas Huth if (shift == 0) { \ 1776fcf5ef2aSThomas Huth *r = *a; \ 1777fcf5ef2aSThomas Huth } else if (leftp) { \ 17783c385a93SMark Cave-Ayland uint64_t carry = a->VsrD(1) >> (64 - shift); \ 1779fcf5ef2aSThomas Huth \ 17803c385a93SMark Cave-Ayland r->VsrD(0) = (a->VsrD(0) << shift) | carry; \ 17813c385a93SMark Cave-Ayland r->VsrD(1) = a->VsrD(1) << shift; \ 1782fcf5ef2aSThomas Huth } else { \ 17833c385a93SMark Cave-Ayland uint64_t carry = a->VsrD(0) << (64 - shift); \ 1784fcf5ef2aSThomas Huth \ 17853c385a93SMark Cave-Ayland r->VsrD(1) = (a->VsrD(1) >> shift) | carry; \ 17863c385a93SMark Cave-Ayland r->VsrD(0) = a->VsrD(0) >> shift; \ 1787fcf5ef2aSThomas Huth } \ 1788fcf5ef2aSThomas Huth } \ 1789fcf5ef2aSThomas Huth } 1790fcf5ef2aSThomas Huth VSHIFT(l, 1) 1791fcf5ef2aSThomas Huth VSHIFT(r, 0) 1792fcf5ef2aSThomas Huth #undef VSHIFT 1793fcf5ef2aSThomas Huth 1794fcf5ef2aSThomas Huth #define VSL(suffix, element, mask) \ 1795fcf5ef2aSThomas Huth void helper_vsl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1796fcf5ef2aSThomas Huth { \ 1797fcf5ef2aSThomas Huth int i; \ 1798fcf5ef2aSThomas Huth \ 1799fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1800fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1801fcf5ef2aSThomas Huth \ 1802fcf5ef2aSThomas Huth r->element[i] = a->element[i] << shift; \ 1803fcf5ef2aSThomas Huth } \ 1804fcf5ef2aSThomas Huth } 1805fcf5ef2aSThomas Huth VSL(b, u8, 0x7) 1806fcf5ef2aSThomas Huth VSL(h, u16, 0x0F) 1807fcf5ef2aSThomas Huth VSL(w, u32, 0x1F) 1808fcf5ef2aSThomas Huth VSL(d, u64, 0x3F) 1809fcf5ef2aSThomas Huth #undef VSL 1810fcf5ef2aSThomas Huth 1811fcf5ef2aSThomas Huth void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1812fcf5ef2aSThomas Huth { 1813fcf5ef2aSThomas Huth int i; 1814fcf5ef2aSThomas Huth unsigned int shift, bytes, size; 1815fcf5ef2aSThomas Huth 1816fcf5ef2aSThomas Huth size = ARRAY_SIZE(r->u8); 1817fcf5ef2aSThomas Huth for (i = 0; i < size; i++) { 1818*63be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 1819*63be02fcSAnton Blanchard bytes = (a->VsrB(i) << 8) + /* extract adjacent bytes */ 1820*63be02fcSAnton Blanchard (((i + 1) < size) ? a->VsrB(i + 1) : 0); 1821*63be02fcSAnton Blanchard r->VsrB(i) = (bytes << shift) >> 8; /* shift and store result */ 1822fcf5ef2aSThomas Huth } 1823fcf5ef2aSThomas Huth } 1824fcf5ef2aSThomas Huth 1825fcf5ef2aSThomas Huth void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1826fcf5ef2aSThomas Huth { 1827fcf5ef2aSThomas Huth int i; 1828fcf5ef2aSThomas Huth unsigned int shift, bytes; 1829fcf5ef2aSThomas Huth 1830b6cb41b2SDavid Gibson /* 1831b6cb41b2SDavid Gibson * Use reverse order, as destination and source register can be 1832b6cb41b2SDavid Gibson * same. Its being modified in place saving temporary, reverse 1833b6cb41b2SDavid Gibson * order will guarantee that computed result is not fed back. 1834fcf5ef2aSThomas Huth */ 1835fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 1836*63be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 1837*63be02fcSAnton Blanchard bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i); 1838fcf5ef2aSThomas Huth /* extract adjacent bytes */ 1839*63be02fcSAnton Blanchard r->VsrB(i) = (bytes >> shift) & 0xFF; /* shift and store result */ 1840fcf5ef2aSThomas Huth } 1841fcf5ef2aSThomas Huth } 1842fcf5ef2aSThomas Huth 1843fcf5ef2aSThomas Huth void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift) 1844fcf5ef2aSThomas Huth { 1845fcf5ef2aSThomas Huth int sh = shift & 0xf; 1846fcf5ef2aSThomas Huth int i; 1847fcf5ef2aSThomas Huth ppc_avr_t result; 1848fcf5ef2aSThomas Huth 1849fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1850fcf5ef2aSThomas Huth int index = sh + i; 1851fcf5ef2aSThomas Huth if (index > 0xf) { 185260594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index - 0x10); 1853fcf5ef2aSThomas Huth } else { 185460594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1855fcf5ef2aSThomas Huth } 1856fcf5ef2aSThomas Huth } 1857fcf5ef2aSThomas Huth *r = result; 1858fcf5ef2aSThomas Huth } 1859fcf5ef2aSThomas Huth 1860fcf5ef2aSThomas Huth void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1861fcf5ef2aSThomas Huth { 18623c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1863fcf5ef2aSThomas Huth 1864fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1865fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1866fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1867fcf5ef2aSThomas Huth #else 1868fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1869fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1870fcf5ef2aSThomas Huth #endif 1871fcf5ef2aSThomas Huth } 1872fcf5ef2aSThomas Huth 1873fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1874fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1875fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1876fcf5ef2aSThomas Huth { \ 18774fff7218SLaurent Vivier memmove(&r->u8[index], &b->u8[8 - sizeof(r->element[0])], \ 1878fcf5ef2aSThomas Huth sizeof(r->element[0])); \ 1879fcf5ef2aSThomas Huth } 1880fcf5ef2aSThomas Huth #else 1881fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1882fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1883fcf5ef2aSThomas Huth { \ 1884fcf5ef2aSThomas Huth uint32_t d = (16 - index) - sizeof(r->element[0]); \ 1885fcf5ef2aSThomas Huth memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0])); \ 1886fcf5ef2aSThomas Huth } 1887fcf5ef2aSThomas Huth #endif 1888fcf5ef2aSThomas Huth VINSERT(b, u8) 1889fcf5ef2aSThomas Huth VINSERT(h, u16) 1890fcf5ef2aSThomas Huth VINSERT(w, u32) 1891fcf5ef2aSThomas Huth VINSERT(d, u64) 1892fcf5ef2aSThomas Huth #undef VINSERT 1893fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1894fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1895fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1896fcf5ef2aSThomas Huth { \ 1897fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1898fcf5ef2aSThomas Huth memmove(&r->u8[8 - es], &b->u8[index], es); \ 1899fcf5ef2aSThomas Huth memset(&r->u8[8], 0, 8); \ 1900fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8 - es); \ 1901fcf5ef2aSThomas Huth } 1902fcf5ef2aSThomas Huth #else 1903fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1904fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1905fcf5ef2aSThomas Huth { \ 1906fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1907fcf5ef2aSThomas Huth uint32_t s = (16 - index) - es; \ 1908fcf5ef2aSThomas Huth memmove(&r->u8[8], &b->u8[s], es); \ 1909fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8); \ 1910fcf5ef2aSThomas Huth memset(&r->u8[8 + es], 0, 8 - es); \ 1911fcf5ef2aSThomas Huth } 1912fcf5ef2aSThomas Huth #endif 1913fcf5ef2aSThomas Huth VEXTRACT(ub, u8) 1914fcf5ef2aSThomas Huth VEXTRACT(uh, u16) 1915fcf5ef2aSThomas Huth VEXTRACT(uw, u32) 1916fcf5ef2aSThomas Huth VEXTRACT(d, u64) 1917fcf5ef2aSThomas Huth #undef VEXTRACT 1918fcf5ef2aSThomas Huth 19198ad901e5SNikunj A Dadhania void helper_xxextractuw(CPUPPCState *env, target_ulong xtn, 19208ad901e5SNikunj A Dadhania target_ulong xbn, uint32_t index) 19218ad901e5SNikunj A Dadhania { 19228ad901e5SNikunj A Dadhania ppc_vsr_t xt, xb; 19238ad901e5SNikunj A Dadhania size_t es = sizeof(uint32_t); 19248ad901e5SNikunj A Dadhania uint32_t ext_index; 19258ad901e5SNikunj A Dadhania int i; 19268ad901e5SNikunj A Dadhania 19278ad901e5SNikunj A Dadhania getVSR(xbn, &xb, env); 19288ad901e5SNikunj A Dadhania memset(&xt, 0, sizeof(xt)); 19298ad901e5SNikunj A Dadhania 19308ad901e5SNikunj A Dadhania ext_index = index; 19318ad901e5SNikunj A Dadhania for (i = 0; i < es; i++, ext_index++) { 193260594feaSMark Cave-Ayland xt.VsrB(8 - es + i) = xb.VsrB(ext_index % 16); 19338ad901e5SNikunj A Dadhania } 19348ad901e5SNikunj A Dadhania 19358ad901e5SNikunj A Dadhania putVSR(xtn, &xt, env); 19368ad901e5SNikunj A Dadhania } 19378ad901e5SNikunj A Dadhania 19383398b742SNikunj A Dadhania void helper_xxinsertw(CPUPPCState *env, target_ulong xtn, 19393398b742SNikunj A Dadhania target_ulong xbn, uint32_t index) 19403398b742SNikunj A Dadhania { 19413398b742SNikunj A Dadhania ppc_vsr_t xt, xb; 19423398b742SNikunj A Dadhania size_t es = sizeof(uint32_t); 19433398b742SNikunj A Dadhania int ins_index, i = 0; 19443398b742SNikunj A Dadhania 19453398b742SNikunj A Dadhania getVSR(xbn, &xb, env); 19463398b742SNikunj A Dadhania getVSR(xtn, &xt, env); 19473398b742SNikunj A Dadhania 19483398b742SNikunj A Dadhania ins_index = index; 19493398b742SNikunj A Dadhania for (i = 0; i < es && ins_index < 16; i++, ins_index++) { 195060594feaSMark Cave-Ayland xt.VsrB(ins_index) = xb.VsrB(8 - es + i); 19513398b742SNikunj A Dadhania } 19523398b742SNikunj A Dadhania 19533398b742SNikunj A Dadhania putVSR(xtn, &xt, env); 19543398b742SNikunj A Dadhania } 19553398b742SNikunj A Dadhania 1956634c5835SMark Cave-Ayland #define VEXT_SIGNED(name, element, cast) \ 1957fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1958fcf5ef2aSThomas Huth { \ 1959fcf5ef2aSThomas Huth int i; \ 196060594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1961634c5835SMark Cave-Ayland r->element[i] = (cast)b->element[i]; \ 1962fcf5ef2aSThomas Huth } \ 1963fcf5ef2aSThomas Huth } 1964634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2w, s32, int8_t) 1965634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2d, s64, int8_t) 1966634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2w, s32, int16_t) 1967634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2d, s64, int16_t) 1968634c5835SMark Cave-Ayland VEXT_SIGNED(vextsw2d, s64, int32_t) 1969fcf5ef2aSThomas Huth #undef VEXT_SIGNED 1970fcf5ef2aSThomas Huth 1971fcf5ef2aSThomas Huth #define VNEG(name, element) \ 1972fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1973fcf5ef2aSThomas Huth { \ 1974fcf5ef2aSThomas Huth int i; \ 197560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1976fcf5ef2aSThomas Huth r->element[i] = -b->element[i]; \ 1977fcf5ef2aSThomas Huth } \ 1978fcf5ef2aSThomas Huth } 1979fcf5ef2aSThomas Huth VNEG(vnegw, s32) 1980fcf5ef2aSThomas Huth VNEG(vnegd, s64) 1981fcf5ef2aSThomas Huth #undef VNEG 1982fcf5ef2aSThomas Huth 1983fcf5ef2aSThomas Huth #define VSR(suffix, element, mask) \ 1984fcf5ef2aSThomas Huth void helper_vsr##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1985fcf5ef2aSThomas Huth { \ 1986fcf5ef2aSThomas Huth int i; \ 1987fcf5ef2aSThomas Huth \ 1988fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1989fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1990fcf5ef2aSThomas Huth r->element[i] = a->element[i] >> shift; \ 1991fcf5ef2aSThomas Huth } \ 1992fcf5ef2aSThomas Huth } 1993fcf5ef2aSThomas Huth VSR(ab, s8, 0x7) 1994fcf5ef2aSThomas Huth VSR(ah, s16, 0xF) 1995fcf5ef2aSThomas Huth VSR(aw, s32, 0x1F) 1996fcf5ef2aSThomas Huth VSR(ad, s64, 0x3F) 1997fcf5ef2aSThomas Huth VSR(b, u8, 0x7) 1998fcf5ef2aSThomas Huth VSR(h, u16, 0xF) 1999fcf5ef2aSThomas Huth VSR(w, u32, 0x1F) 2000fcf5ef2aSThomas Huth VSR(d, u64, 0x3F) 2001fcf5ef2aSThomas Huth #undef VSR 2002fcf5ef2aSThomas Huth 2003fcf5ef2aSThomas Huth void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2004fcf5ef2aSThomas Huth { 20053c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 2006fcf5ef2aSThomas Huth 2007fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2008fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 2009fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 2010fcf5ef2aSThomas Huth #else 2011fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 2012fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 2013fcf5ef2aSThomas Huth #endif 2014fcf5ef2aSThomas Huth } 2015fcf5ef2aSThomas Huth 2016fcf5ef2aSThomas Huth void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2017fcf5ef2aSThomas Huth { 2018fcf5ef2aSThomas Huth int i; 2019fcf5ef2aSThomas Huth 2020fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2021fcf5ef2aSThomas Huth r->u32[i] = a->u32[i] >= b->u32[i]; 2022fcf5ef2aSThomas Huth } 2023fcf5ef2aSThomas Huth } 2024fcf5ef2aSThomas Huth 2025fcf5ef2aSThomas Huth void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2026fcf5ef2aSThomas Huth { 2027fcf5ef2aSThomas Huth int64_t t; 2028fcf5ef2aSThomas Huth int i, upper; 2029fcf5ef2aSThomas Huth ppc_avr_t result; 2030fcf5ef2aSThomas Huth int sat = 0; 2031fcf5ef2aSThomas Huth 2032fcf5ef2aSThomas Huth upper = ARRAY_SIZE(r->s32) - 1; 203360594feaSMark Cave-Ayland t = (int64_t)b->VsrSW(upper); 2034fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 203560594feaSMark Cave-Ayland t += a->VsrSW(i); 203660594feaSMark Cave-Ayland result.VsrSW(i) = 0; 2037fcf5ef2aSThomas Huth } 203860594feaSMark Cave-Ayland result.VsrSW(upper) = cvtsdsw(t, &sat); 2039fcf5ef2aSThomas Huth *r = result; 2040fcf5ef2aSThomas Huth 2041fcf5ef2aSThomas Huth if (sat) { 20426175f5a0SRichard Henderson set_vscr_sat(env); 2043fcf5ef2aSThomas Huth } 2044fcf5ef2aSThomas Huth } 2045fcf5ef2aSThomas Huth 2046fcf5ef2aSThomas Huth void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2047fcf5ef2aSThomas Huth { 2048fcf5ef2aSThomas Huth int i, j, upper; 2049fcf5ef2aSThomas Huth ppc_avr_t result; 2050fcf5ef2aSThomas Huth int sat = 0; 2051fcf5ef2aSThomas Huth 2052fcf5ef2aSThomas Huth upper = 1; 2053fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 205460594feaSMark Cave-Ayland int64_t t = (int64_t)b->VsrSW(upper + i * 2); 2055fcf5ef2aSThomas Huth 205660594feaSMark Cave-Ayland result.VsrW(i) = 0; 2057fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u64); j++) { 205860594feaSMark Cave-Ayland t += a->VsrSW(2 * i + j); 2059fcf5ef2aSThomas Huth } 206060594feaSMark Cave-Ayland result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat); 2061fcf5ef2aSThomas Huth } 2062fcf5ef2aSThomas Huth 2063fcf5ef2aSThomas Huth *r = result; 2064fcf5ef2aSThomas Huth if (sat) { 20656175f5a0SRichard Henderson set_vscr_sat(env); 2066fcf5ef2aSThomas Huth } 2067fcf5ef2aSThomas Huth } 2068fcf5ef2aSThomas Huth 2069fcf5ef2aSThomas Huth void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2070fcf5ef2aSThomas Huth { 2071fcf5ef2aSThomas Huth int i, j; 2072fcf5ef2aSThomas Huth int sat = 0; 2073fcf5ef2aSThomas Huth 2074fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2075fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2076fcf5ef2aSThomas Huth 2077fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->s32); j++) { 2078fcf5ef2aSThomas Huth t += a->s8[4 * i + j]; 2079fcf5ef2aSThomas Huth } 2080fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2081fcf5ef2aSThomas Huth } 2082fcf5ef2aSThomas Huth 2083fcf5ef2aSThomas Huth if (sat) { 20846175f5a0SRichard Henderson set_vscr_sat(env); 2085fcf5ef2aSThomas Huth } 2086fcf5ef2aSThomas Huth } 2087fcf5ef2aSThomas Huth 2088fcf5ef2aSThomas Huth void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2089fcf5ef2aSThomas Huth { 2090fcf5ef2aSThomas Huth int sat = 0; 2091fcf5ef2aSThomas Huth int i; 2092fcf5ef2aSThomas Huth 2093fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2094fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2095fcf5ef2aSThomas Huth 2096fcf5ef2aSThomas Huth t += a->s16[2 * i] + a->s16[2 * i + 1]; 2097fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2098fcf5ef2aSThomas Huth } 2099fcf5ef2aSThomas Huth 2100fcf5ef2aSThomas Huth if (sat) { 21016175f5a0SRichard Henderson set_vscr_sat(env); 2102fcf5ef2aSThomas Huth } 2103fcf5ef2aSThomas Huth } 2104fcf5ef2aSThomas Huth 2105fcf5ef2aSThomas Huth void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2106fcf5ef2aSThomas Huth { 2107fcf5ef2aSThomas Huth int i, j; 2108fcf5ef2aSThomas Huth int sat = 0; 2109fcf5ef2aSThomas Huth 2110fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2111fcf5ef2aSThomas Huth uint64_t t = (uint64_t)b->u32[i]; 2112fcf5ef2aSThomas Huth 2113fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u32); j++) { 2114fcf5ef2aSThomas Huth t += a->u8[4 * i + j]; 2115fcf5ef2aSThomas Huth } 2116fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 2117fcf5ef2aSThomas Huth } 2118fcf5ef2aSThomas Huth 2119fcf5ef2aSThomas Huth if (sat) { 21206175f5a0SRichard Henderson set_vscr_sat(env); 2121fcf5ef2aSThomas Huth } 2122fcf5ef2aSThomas Huth } 2123fcf5ef2aSThomas Huth 2124fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2125fcf5ef2aSThomas Huth #define UPKHI 1 2126fcf5ef2aSThomas Huth #define UPKLO 0 2127fcf5ef2aSThomas Huth #else 2128fcf5ef2aSThomas Huth #define UPKHI 0 2129fcf5ef2aSThomas Huth #define UPKLO 1 2130fcf5ef2aSThomas Huth #endif 2131fcf5ef2aSThomas Huth #define VUPKPX(suffix, hi) \ 2132fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2133fcf5ef2aSThomas Huth { \ 2134fcf5ef2aSThomas Huth int i; \ 2135fcf5ef2aSThomas Huth ppc_avr_t result; \ 2136fcf5ef2aSThomas Huth \ 2137fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \ 2138fcf5ef2aSThomas Huth uint16_t e = b->u16[hi ? i : i + 4]; \ 2139fcf5ef2aSThomas Huth uint8_t a = (e >> 15) ? 0xff : 0; \ 2140fcf5ef2aSThomas Huth uint8_t r = (e >> 10) & 0x1f; \ 2141fcf5ef2aSThomas Huth uint8_t g = (e >> 5) & 0x1f; \ 2142fcf5ef2aSThomas Huth uint8_t b = e & 0x1f; \ 2143fcf5ef2aSThomas Huth \ 2144fcf5ef2aSThomas Huth result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \ 2145fcf5ef2aSThomas Huth } \ 2146fcf5ef2aSThomas Huth *r = result; \ 2147fcf5ef2aSThomas Huth } 2148fcf5ef2aSThomas Huth VUPKPX(lpx, UPKLO) 2149fcf5ef2aSThomas Huth VUPKPX(hpx, UPKHI) 2150fcf5ef2aSThomas Huth #undef VUPKPX 2151fcf5ef2aSThomas Huth 2152fcf5ef2aSThomas Huth #define VUPK(suffix, unpacked, packee, hi) \ 2153fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2154fcf5ef2aSThomas Huth { \ 2155fcf5ef2aSThomas Huth int i; \ 2156fcf5ef2aSThomas Huth ppc_avr_t result; \ 2157fcf5ef2aSThomas Huth \ 2158fcf5ef2aSThomas Huth if (hi) { \ 2159fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \ 2160fcf5ef2aSThomas Huth result.unpacked[i] = b->packee[i]; \ 2161fcf5ef2aSThomas Huth } \ 2162fcf5ef2aSThomas Huth } else { \ 2163fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \ 2164fcf5ef2aSThomas Huth i++) { \ 2165fcf5ef2aSThomas Huth result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \ 2166fcf5ef2aSThomas Huth } \ 2167fcf5ef2aSThomas Huth } \ 2168fcf5ef2aSThomas Huth *r = result; \ 2169fcf5ef2aSThomas Huth } 2170fcf5ef2aSThomas Huth VUPK(hsb, s16, s8, UPKHI) 2171fcf5ef2aSThomas Huth VUPK(hsh, s32, s16, UPKHI) 2172fcf5ef2aSThomas Huth VUPK(hsw, s64, s32, UPKHI) 2173fcf5ef2aSThomas Huth VUPK(lsb, s16, s8, UPKLO) 2174fcf5ef2aSThomas Huth VUPK(lsh, s32, s16, UPKLO) 2175fcf5ef2aSThomas Huth VUPK(lsw, s64, s32, UPKLO) 2176fcf5ef2aSThomas Huth #undef VUPK 2177fcf5ef2aSThomas Huth #undef UPKHI 2178fcf5ef2aSThomas Huth #undef UPKLO 2179fcf5ef2aSThomas Huth 2180fcf5ef2aSThomas Huth #define VGENERIC_DO(name, element) \ 2181fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \ 2182fcf5ef2aSThomas Huth { \ 2183fcf5ef2aSThomas Huth int i; \ 2184fcf5ef2aSThomas Huth \ 218560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 2186fcf5ef2aSThomas Huth r->element[i] = name(b->element[i]); \ 2187fcf5ef2aSThomas Huth } \ 2188fcf5ef2aSThomas Huth } 2189fcf5ef2aSThomas Huth 2190fcf5ef2aSThomas Huth #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8) 2191fcf5ef2aSThomas Huth #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16) 2192fcf5ef2aSThomas Huth #define clzw(v) clz32((v)) 2193fcf5ef2aSThomas Huth #define clzd(v) clz64((v)) 2194fcf5ef2aSThomas Huth 2195fcf5ef2aSThomas Huth VGENERIC_DO(clzb, u8) 2196fcf5ef2aSThomas Huth VGENERIC_DO(clzh, u16) 2197fcf5ef2aSThomas Huth VGENERIC_DO(clzw, u32) 2198fcf5ef2aSThomas Huth VGENERIC_DO(clzd, u64) 2199fcf5ef2aSThomas Huth 2200fcf5ef2aSThomas Huth #undef clzb 2201fcf5ef2aSThomas Huth #undef clzh 2202fcf5ef2aSThomas Huth #undef clzw 2203fcf5ef2aSThomas Huth #undef clzd 2204fcf5ef2aSThomas Huth 2205fcf5ef2aSThomas Huth #define ctzb(v) ((v) ? ctz32(v) : 8) 2206fcf5ef2aSThomas Huth #define ctzh(v) ((v) ? ctz32(v) : 16) 2207fcf5ef2aSThomas Huth #define ctzw(v) ctz32((v)) 2208fcf5ef2aSThomas Huth #define ctzd(v) ctz64((v)) 2209fcf5ef2aSThomas Huth 2210fcf5ef2aSThomas Huth VGENERIC_DO(ctzb, u8) 2211fcf5ef2aSThomas Huth VGENERIC_DO(ctzh, u16) 2212fcf5ef2aSThomas Huth VGENERIC_DO(ctzw, u32) 2213fcf5ef2aSThomas Huth VGENERIC_DO(ctzd, u64) 2214fcf5ef2aSThomas Huth 2215fcf5ef2aSThomas Huth #undef ctzb 2216fcf5ef2aSThomas Huth #undef ctzh 2217fcf5ef2aSThomas Huth #undef ctzw 2218fcf5ef2aSThomas Huth #undef ctzd 2219fcf5ef2aSThomas Huth 2220fcf5ef2aSThomas Huth #define popcntb(v) ctpop8(v) 2221fcf5ef2aSThomas Huth #define popcnth(v) ctpop16(v) 2222fcf5ef2aSThomas Huth #define popcntw(v) ctpop32(v) 2223fcf5ef2aSThomas Huth #define popcntd(v) ctpop64(v) 2224fcf5ef2aSThomas Huth 2225fcf5ef2aSThomas Huth VGENERIC_DO(popcntb, u8) 2226fcf5ef2aSThomas Huth VGENERIC_DO(popcnth, u16) 2227fcf5ef2aSThomas Huth VGENERIC_DO(popcntw, u32) 2228fcf5ef2aSThomas Huth VGENERIC_DO(popcntd, u64) 2229fcf5ef2aSThomas Huth 2230fcf5ef2aSThomas Huth #undef popcntb 2231fcf5ef2aSThomas Huth #undef popcnth 2232fcf5ef2aSThomas Huth #undef popcntw 2233fcf5ef2aSThomas Huth #undef popcntd 2234fcf5ef2aSThomas Huth 2235fcf5ef2aSThomas Huth #undef VGENERIC_DO 2236fcf5ef2aSThomas Huth 2237fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2238fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 0, 1 } } 2239fcf5ef2aSThomas Huth #else 2240fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 1, 0 } } 2241fcf5ef2aSThomas Huth #endif 2242fcf5ef2aSThomas Huth 2243fcf5ef2aSThomas Huth #ifndef CONFIG_INT128 2244fcf5ef2aSThomas Huth 2245fcf5ef2aSThomas Huth static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a) 2246fcf5ef2aSThomas Huth { 2247fcf5ef2aSThomas Huth t->u64[0] = ~a.u64[0]; 2248fcf5ef2aSThomas Huth t->u64[1] = ~a.u64[1]; 2249fcf5ef2aSThomas Huth } 2250fcf5ef2aSThomas Huth 2251fcf5ef2aSThomas Huth static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b) 2252fcf5ef2aSThomas Huth { 22533c385a93SMark Cave-Ayland if (a.VsrD(0) < b.VsrD(0)) { 2254fcf5ef2aSThomas Huth return -1; 22553c385a93SMark Cave-Ayland } else if (a.VsrD(0) > b.VsrD(0)) { 2256fcf5ef2aSThomas Huth return 1; 22573c385a93SMark Cave-Ayland } else if (a.VsrD(1) < b.VsrD(1)) { 2258fcf5ef2aSThomas Huth return -1; 22593c385a93SMark Cave-Ayland } else if (a.VsrD(1) > b.VsrD(1)) { 2260fcf5ef2aSThomas Huth return 1; 2261fcf5ef2aSThomas Huth } else { 2262fcf5ef2aSThomas Huth return 0; 2263fcf5ef2aSThomas Huth } 2264fcf5ef2aSThomas Huth } 2265fcf5ef2aSThomas Huth 2266fcf5ef2aSThomas Huth static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2267fcf5ef2aSThomas Huth { 22683c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 22693c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 22703c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 2271fcf5ef2aSThomas Huth } 2272fcf5ef2aSThomas Huth 2273fcf5ef2aSThomas Huth static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2274fcf5ef2aSThomas Huth { 2275fcf5ef2aSThomas Huth ppc_avr_t not_a; 22763c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 22773c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 22783c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 2279fcf5ef2aSThomas Huth avr_qw_not(¬_a, a); 2280fcf5ef2aSThomas Huth return avr_qw_cmpu(not_a, b) < 0; 2281fcf5ef2aSThomas Huth } 2282fcf5ef2aSThomas Huth 2283fcf5ef2aSThomas Huth #endif 2284fcf5ef2aSThomas Huth 2285fcf5ef2aSThomas Huth void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2286fcf5ef2aSThomas Huth { 2287fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2288fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128; 2289fcf5ef2aSThomas Huth #else 2290fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2291fcf5ef2aSThomas Huth #endif 2292fcf5ef2aSThomas Huth } 2293fcf5ef2aSThomas Huth 2294fcf5ef2aSThomas Huth void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2295fcf5ef2aSThomas Huth { 2296fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2297fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128 + (c->u128 & 1); 2298fcf5ef2aSThomas Huth #else 2299fcf5ef2aSThomas Huth 23003c385a93SMark Cave-Ayland if (c->VsrD(1) & 1) { 2301fcf5ef2aSThomas Huth ppc_avr_t tmp; 2302fcf5ef2aSThomas Huth 23033c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 23043c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2305fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2306fcf5ef2aSThomas Huth avr_qw_add(r, tmp, *b); 2307fcf5ef2aSThomas Huth } else { 2308fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2309fcf5ef2aSThomas Huth } 2310fcf5ef2aSThomas Huth #endif 2311fcf5ef2aSThomas Huth } 2312fcf5ef2aSThomas Huth 2313fcf5ef2aSThomas Huth void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2314fcf5ef2aSThomas Huth { 2315fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2316fcf5ef2aSThomas Huth r->u128 = (~a->u128 < b->u128); 2317fcf5ef2aSThomas Huth #else 2318fcf5ef2aSThomas Huth ppc_avr_t not_a; 2319fcf5ef2aSThomas Huth 2320fcf5ef2aSThomas Huth avr_qw_not(¬_a, *a); 2321fcf5ef2aSThomas Huth 23223c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23233c385a93SMark Cave-Ayland r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0); 2324fcf5ef2aSThomas Huth #endif 2325fcf5ef2aSThomas Huth } 2326fcf5ef2aSThomas Huth 2327fcf5ef2aSThomas Huth void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2328fcf5ef2aSThomas Huth { 2329fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2330fcf5ef2aSThomas Huth int carry_out = (~a->u128 < b->u128); 2331fcf5ef2aSThomas Huth if (!carry_out && (c->u128 & 1)) { 2332fcf5ef2aSThomas Huth carry_out = ((a->u128 + b->u128 + 1) == 0) && 2333fcf5ef2aSThomas Huth ((a->u128 != 0) || (b->u128 != 0)); 2334fcf5ef2aSThomas Huth } 2335fcf5ef2aSThomas Huth r->u128 = carry_out; 2336fcf5ef2aSThomas Huth #else 2337fcf5ef2aSThomas Huth 23383c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2339fcf5ef2aSThomas Huth int carry_out = 0; 2340fcf5ef2aSThomas Huth ppc_avr_t tmp; 2341fcf5ef2aSThomas Huth 2342fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, *a, *b); 2343fcf5ef2aSThomas Huth 2344fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2345fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2346fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, tmp, one); 2347fcf5ef2aSThomas Huth } 23483c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23493c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2350fcf5ef2aSThomas Huth #endif 2351fcf5ef2aSThomas Huth } 2352fcf5ef2aSThomas Huth 2353fcf5ef2aSThomas Huth void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2354fcf5ef2aSThomas Huth { 2355fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2356fcf5ef2aSThomas Huth r->u128 = a->u128 - b->u128; 2357fcf5ef2aSThomas Huth #else 2358fcf5ef2aSThomas Huth ppc_avr_t tmp; 2359fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2360fcf5ef2aSThomas Huth 2361fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2362fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2363fcf5ef2aSThomas Huth avr_qw_add(r, tmp, one); 2364fcf5ef2aSThomas Huth #endif 2365fcf5ef2aSThomas Huth } 2366fcf5ef2aSThomas Huth 2367fcf5ef2aSThomas Huth void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2368fcf5ef2aSThomas Huth { 2369fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2370fcf5ef2aSThomas Huth r->u128 = a->u128 + ~b->u128 + (c->u128 & 1); 2371fcf5ef2aSThomas Huth #else 2372fcf5ef2aSThomas Huth ppc_avr_t tmp, sum; 2373fcf5ef2aSThomas Huth 2374fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2375fcf5ef2aSThomas Huth avr_qw_add(&sum, *a, tmp); 2376fcf5ef2aSThomas Huth 23773c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 23783c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2379fcf5ef2aSThomas Huth avr_qw_add(r, sum, tmp); 2380fcf5ef2aSThomas Huth #endif 2381fcf5ef2aSThomas Huth } 2382fcf5ef2aSThomas Huth 2383fcf5ef2aSThomas Huth void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2384fcf5ef2aSThomas Huth { 2385fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2386fcf5ef2aSThomas Huth r->u128 = (~a->u128 < ~b->u128) || 2387fcf5ef2aSThomas Huth (a->u128 + ~b->u128 == (__uint128_t)-1); 2388fcf5ef2aSThomas Huth #else 2389fcf5ef2aSThomas Huth int carry = (avr_qw_cmpu(*a, *b) > 0); 2390fcf5ef2aSThomas Huth if (!carry) { 2391fcf5ef2aSThomas Huth ppc_avr_t tmp; 2392fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2393fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 23943c385a93SMark Cave-Ayland carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull)); 2395fcf5ef2aSThomas Huth } 23963c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23973c385a93SMark Cave-Ayland r->VsrD(1) = carry; 2398fcf5ef2aSThomas Huth #endif 2399fcf5ef2aSThomas Huth } 2400fcf5ef2aSThomas Huth 2401fcf5ef2aSThomas Huth void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2402fcf5ef2aSThomas Huth { 2403fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2404fcf5ef2aSThomas Huth r->u128 = 2405fcf5ef2aSThomas Huth (~a->u128 < ~b->u128) || 2406fcf5ef2aSThomas Huth ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1)); 2407fcf5ef2aSThomas Huth #else 24083c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2409fcf5ef2aSThomas Huth int carry_out = (avr_qw_cmpu(*a, *b) > 0); 2410fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2411fcf5ef2aSThomas Huth ppc_avr_t tmp; 2412fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2413fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 24143c385a93SMark Cave-Ayland carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull)); 2415fcf5ef2aSThomas Huth } 2416fcf5ef2aSThomas Huth 24173c385a93SMark Cave-Ayland r->VsrD(0) = 0; 24183c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2419fcf5ef2aSThomas Huth #endif 2420fcf5ef2aSThomas Huth } 2421fcf5ef2aSThomas Huth 2422fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_1 0xC 2423fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_2 0xF 2424fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_1 0xA 2425fcf5ef2aSThomas Huth #define BCD_NEG_PREF 0xD 2426fcf5ef2aSThomas Huth #define BCD_NEG_ALT 0xB 2427fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_2 0xE 2428fcf5ef2aSThomas Huth #define NATIONAL_PLUS 0x2B 2429fcf5ef2aSThomas Huth #define NATIONAL_NEG 0x2D 2430fcf5ef2aSThomas Huth 2431fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2432365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) (15 - ((n) / 2)) 2433fcf5ef2aSThomas Huth #else 2434365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) ((n) / 2) 2435fcf5ef2aSThomas Huth #endif 2436fcf5ef2aSThomas Huth 2437fcf5ef2aSThomas Huth static int bcd_get_sgn(ppc_avr_t *bcd) 2438fcf5ef2aSThomas Huth { 2439fcf5ef2aSThomas Huth switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) { 2440fcf5ef2aSThomas Huth case BCD_PLUS_PREF_1: 2441fcf5ef2aSThomas Huth case BCD_PLUS_PREF_2: 2442fcf5ef2aSThomas Huth case BCD_PLUS_ALT_1: 2443fcf5ef2aSThomas Huth case BCD_PLUS_ALT_2: 2444fcf5ef2aSThomas Huth { 2445fcf5ef2aSThomas Huth return 1; 2446fcf5ef2aSThomas Huth } 2447fcf5ef2aSThomas Huth 2448fcf5ef2aSThomas Huth case BCD_NEG_PREF: 2449fcf5ef2aSThomas Huth case BCD_NEG_ALT: 2450fcf5ef2aSThomas Huth { 2451fcf5ef2aSThomas Huth return -1; 2452fcf5ef2aSThomas Huth } 2453fcf5ef2aSThomas Huth 2454fcf5ef2aSThomas Huth default: 2455fcf5ef2aSThomas Huth { 2456fcf5ef2aSThomas Huth return 0; 2457fcf5ef2aSThomas Huth } 2458fcf5ef2aSThomas Huth } 2459fcf5ef2aSThomas Huth } 2460fcf5ef2aSThomas Huth 2461fcf5ef2aSThomas Huth static int bcd_preferred_sgn(int sgn, int ps) 2462fcf5ef2aSThomas Huth { 2463fcf5ef2aSThomas Huth if (sgn >= 0) { 2464fcf5ef2aSThomas Huth return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2; 2465fcf5ef2aSThomas Huth } else { 2466fcf5ef2aSThomas Huth return BCD_NEG_PREF; 2467fcf5ef2aSThomas Huth } 2468fcf5ef2aSThomas Huth } 2469fcf5ef2aSThomas Huth 2470fcf5ef2aSThomas Huth static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid) 2471fcf5ef2aSThomas Huth { 2472fcf5ef2aSThomas Huth uint8_t result; 2473fcf5ef2aSThomas Huth if (n & 1) { 2474fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] >> 4; 2475fcf5ef2aSThomas Huth } else { 2476fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF; 2477fcf5ef2aSThomas Huth } 2478fcf5ef2aSThomas Huth 2479fcf5ef2aSThomas Huth if (unlikely(result > 9)) { 2480fcf5ef2aSThomas Huth *invalid = true; 2481fcf5ef2aSThomas Huth } 2482fcf5ef2aSThomas Huth return result; 2483fcf5ef2aSThomas Huth } 2484fcf5ef2aSThomas Huth 2485fcf5ef2aSThomas Huth static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n) 2486fcf5ef2aSThomas Huth { 2487fcf5ef2aSThomas Huth if (n & 1) { 2488fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F; 2489fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= (digit << 4); 2490fcf5ef2aSThomas Huth } else { 2491fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0; 2492fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= digit; 2493fcf5ef2aSThomas Huth } 2494fcf5ef2aSThomas Huth } 2495fcf5ef2aSThomas Huth 2496071663dfSJose Ricardo Ziviani static bool bcd_is_valid(ppc_avr_t *bcd) 2497071663dfSJose Ricardo Ziviani { 2498071663dfSJose Ricardo Ziviani int i; 2499071663dfSJose Ricardo Ziviani int invalid = 0; 2500071663dfSJose Ricardo Ziviani 2501071663dfSJose Ricardo Ziviani if (bcd_get_sgn(bcd) == 0) { 2502071663dfSJose Ricardo Ziviani return false; 2503071663dfSJose Ricardo Ziviani } 2504071663dfSJose Ricardo Ziviani 2505071663dfSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2506071663dfSJose Ricardo Ziviani bcd_get_digit(bcd, i, &invalid); 2507071663dfSJose Ricardo Ziviani if (unlikely(invalid)) { 2508071663dfSJose Ricardo Ziviani return false; 2509071663dfSJose Ricardo Ziviani } 2510071663dfSJose Ricardo Ziviani } 2511071663dfSJose Ricardo Ziviani return true; 2512071663dfSJose Ricardo Ziviani } 2513071663dfSJose Ricardo Ziviani 2514fcf5ef2aSThomas Huth static int bcd_cmp_zero(ppc_avr_t *bcd) 2515fcf5ef2aSThomas Huth { 25163c385a93SMark Cave-Ayland if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) { 2517efa73196SNikunj A Dadhania return CRF_EQ; 2518fcf5ef2aSThomas Huth } else { 2519efa73196SNikunj A Dadhania return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT; 2520fcf5ef2aSThomas Huth } 2521fcf5ef2aSThomas Huth } 2522fcf5ef2aSThomas Huth 2523fcf5ef2aSThomas Huth static uint16_t get_national_digit(ppc_avr_t *reg, int n) 2524fcf5ef2aSThomas Huth { 252560594feaSMark Cave-Ayland return reg->VsrH(7 - n); 2526fcf5ef2aSThomas Huth } 2527fcf5ef2aSThomas Huth 2528fcf5ef2aSThomas Huth static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n) 2529fcf5ef2aSThomas Huth { 253060594feaSMark Cave-Ayland reg->VsrH(7 - n) = val; 2531fcf5ef2aSThomas Huth } 2532fcf5ef2aSThomas Huth 2533fcf5ef2aSThomas Huth static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b) 2534fcf5ef2aSThomas Huth { 2535fcf5ef2aSThomas Huth int i; 2536fcf5ef2aSThomas Huth int invalid = 0; 2537fcf5ef2aSThomas Huth for (i = 31; i > 0; i--) { 2538fcf5ef2aSThomas Huth uint8_t dig_a = bcd_get_digit(a, i, &invalid); 2539fcf5ef2aSThomas Huth uint8_t dig_b = bcd_get_digit(b, i, &invalid); 2540fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2541fcf5ef2aSThomas Huth return 0; /* doesn't matter */ 2542fcf5ef2aSThomas Huth } else if (dig_a > dig_b) { 2543fcf5ef2aSThomas Huth return 1; 2544fcf5ef2aSThomas Huth } else if (dig_a < dig_b) { 2545fcf5ef2aSThomas Huth return -1; 2546fcf5ef2aSThomas Huth } 2547fcf5ef2aSThomas Huth } 2548fcf5ef2aSThomas Huth 2549fcf5ef2aSThomas Huth return 0; 2550fcf5ef2aSThomas Huth } 2551fcf5ef2aSThomas Huth 2552d03b174aSYasmin Beatriz static void bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2553fcf5ef2aSThomas Huth int *overflow) 2554fcf5ef2aSThomas Huth { 2555fcf5ef2aSThomas Huth int carry = 0; 2556fcf5ef2aSThomas Huth int i; 2557fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2558fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) + 2559fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2560fcf5ef2aSThomas Huth if (digit > 9) { 2561fcf5ef2aSThomas Huth carry = 1; 2562fcf5ef2aSThomas Huth digit -= 10; 2563fcf5ef2aSThomas Huth } else { 2564fcf5ef2aSThomas Huth carry = 0; 2565fcf5ef2aSThomas Huth } 2566fcf5ef2aSThomas Huth 2567fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2568fcf5ef2aSThomas Huth } 2569fcf5ef2aSThomas Huth 2570fcf5ef2aSThomas Huth *overflow = carry; 2571fcf5ef2aSThomas Huth } 2572fcf5ef2aSThomas Huth 2573d03b174aSYasmin Beatriz static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2574fcf5ef2aSThomas Huth int *overflow) 2575fcf5ef2aSThomas Huth { 2576fcf5ef2aSThomas Huth int carry = 0; 2577fcf5ef2aSThomas Huth int i; 2578d03b174aSYasmin Beatriz 2579fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2580fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) - 2581fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2582fcf5ef2aSThomas Huth if (digit & 0x80) { 2583fcf5ef2aSThomas Huth carry = -1; 2584fcf5ef2aSThomas Huth digit += 10; 2585fcf5ef2aSThomas Huth } else { 2586fcf5ef2aSThomas Huth carry = 0; 2587fcf5ef2aSThomas Huth } 2588fcf5ef2aSThomas Huth 2589fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2590fcf5ef2aSThomas Huth } 2591fcf5ef2aSThomas Huth 2592fcf5ef2aSThomas Huth *overflow = carry; 2593fcf5ef2aSThomas Huth } 2594fcf5ef2aSThomas Huth 2595fcf5ef2aSThomas Huth uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2596fcf5ef2aSThomas Huth { 2597fcf5ef2aSThomas Huth 2598fcf5ef2aSThomas Huth int sgna = bcd_get_sgn(a); 2599fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2600fcf5ef2aSThomas Huth int invalid = (sgna == 0) || (sgnb == 0); 2601fcf5ef2aSThomas Huth int overflow = 0; 2602fcf5ef2aSThomas Huth uint32_t cr = 0; 2603fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 2604fcf5ef2aSThomas Huth 2605fcf5ef2aSThomas Huth if (!invalid) { 2606fcf5ef2aSThomas Huth if (sgna == sgnb) { 2607fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2608d03b174aSYasmin Beatriz bcd_add_mag(&result, a, b, &invalid, &overflow); 2609d03b174aSYasmin Beatriz cr = bcd_cmp_zero(&result); 2610fcf5ef2aSThomas Huth } else { 2611d03b174aSYasmin Beatriz int magnitude = bcd_cmp_mag(a, b); 2612d03b174aSYasmin Beatriz if (magnitude > 0) { 2613d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2614d03b174aSYasmin Beatriz bcd_sub_mag(&result, a, b, &invalid, &overflow); 2615d03b174aSYasmin Beatriz cr = (sgna > 0) ? CRF_GT : CRF_LT; 2616d03b174aSYasmin Beatriz } else if (magnitude < 0) { 2617fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps); 2618d03b174aSYasmin Beatriz bcd_sub_mag(&result, b, a, &invalid, &overflow); 2619efa73196SNikunj A Dadhania cr = (sgnb > 0) ? CRF_GT : CRF_LT; 2620d03b174aSYasmin Beatriz } else { 2621d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(0, ps); 2622d03b174aSYasmin Beatriz cr = CRF_EQ; 2623d03b174aSYasmin Beatriz } 2624fcf5ef2aSThomas Huth } 2625fcf5ef2aSThomas Huth } 2626fcf5ef2aSThomas Huth 2627fcf5ef2aSThomas Huth if (unlikely(invalid)) { 26283c385a93SMark Cave-Ayland result.VsrD(0) = result.VsrD(1) = -1; 2629efa73196SNikunj A Dadhania cr = CRF_SO; 2630fcf5ef2aSThomas Huth } else if (overflow) { 2631efa73196SNikunj A Dadhania cr |= CRF_SO; 2632fcf5ef2aSThomas Huth } 2633fcf5ef2aSThomas Huth 2634fcf5ef2aSThomas Huth *r = result; 2635fcf5ef2aSThomas Huth 2636fcf5ef2aSThomas Huth return cr; 2637fcf5ef2aSThomas Huth } 2638fcf5ef2aSThomas Huth 2639fcf5ef2aSThomas Huth uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2640fcf5ef2aSThomas Huth { 2641fcf5ef2aSThomas Huth ppc_avr_t bcopy = *b; 2642fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2643fcf5ef2aSThomas Huth if (sgnb < 0) { 2644fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0); 2645fcf5ef2aSThomas Huth } else if (sgnb > 0) { 2646fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_NEG_PREF, 0); 2647fcf5ef2aSThomas Huth } 2648fcf5ef2aSThomas Huth /* else invalid ... defer to bcdadd code for proper handling */ 2649fcf5ef2aSThomas Huth 2650fcf5ef2aSThomas Huth return helper_bcdadd(r, a, &bcopy, ps); 2651fcf5ef2aSThomas Huth } 2652fcf5ef2aSThomas Huth 2653fcf5ef2aSThomas Huth uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2654fcf5ef2aSThomas Huth { 2655fcf5ef2aSThomas Huth int i; 2656fcf5ef2aSThomas Huth int cr = 0; 2657fcf5ef2aSThomas Huth uint16_t national = 0; 2658fcf5ef2aSThomas Huth uint16_t sgnb = get_national_digit(b, 0); 2659fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2660fcf5ef2aSThomas Huth int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG); 2661fcf5ef2aSThomas Huth 2662fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2663fcf5ef2aSThomas Huth national = get_national_digit(b, i); 2664fcf5ef2aSThomas Huth if (unlikely(national < 0x30 || national > 0x39)) { 2665fcf5ef2aSThomas Huth invalid = 1; 2666fcf5ef2aSThomas Huth break; 2667fcf5ef2aSThomas Huth } 2668fcf5ef2aSThomas Huth 2669fcf5ef2aSThomas Huth bcd_put_digit(&ret, national & 0xf, i); 2670fcf5ef2aSThomas Huth } 2671fcf5ef2aSThomas Huth 2672fcf5ef2aSThomas Huth if (sgnb == NATIONAL_PLUS) { 2673fcf5ef2aSThomas Huth bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0); 2674fcf5ef2aSThomas Huth } else { 2675fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2676fcf5ef2aSThomas Huth } 2677fcf5ef2aSThomas Huth 2678fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2679fcf5ef2aSThomas Huth 2680fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2681efa73196SNikunj A Dadhania cr = CRF_SO; 2682fcf5ef2aSThomas Huth } 2683fcf5ef2aSThomas Huth 2684fcf5ef2aSThomas Huth *r = ret; 2685fcf5ef2aSThomas Huth 2686fcf5ef2aSThomas Huth return cr; 2687fcf5ef2aSThomas Huth } 2688fcf5ef2aSThomas Huth 2689fcf5ef2aSThomas Huth uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2690fcf5ef2aSThomas Huth { 2691fcf5ef2aSThomas Huth int i; 2692fcf5ef2aSThomas Huth int cr = 0; 2693fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2694fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2695fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2696fcf5ef2aSThomas Huth 26973c385a93SMark Cave-Ayland int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0); 2698fcf5ef2aSThomas Huth 2699fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2700fcf5ef2aSThomas Huth set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i); 2701fcf5ef2aSThomas Huth 2702fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2703fcf5ef2aSThomas Huth break; 2704fcf5ef2aSThomas Huth } 2705fcf5ef2aSThomas Huth } 2706fcf5ef2aSThomas Huth set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0); 2707fcf5ef2aSThomas Huth 2708fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2709fcf5ef2aSThomas Huth 2710fcf5ef2aSThomas Huth if (ox_flag) { 2711efa73196SNikunj A Dadhania cr |= CRF_SO; 2712fcf5ef2aSThomas Huth } 2713fcf5ef2aSThomas Huth 2714fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2715efa73196SNikunj A Dadhania cr = CRF_SO; 2716fcf5ef2aSThomas Huth } 2717fcf5ef2aSThomas Huth 2718fcf5ef2aSThomas Huth *r = ret; 2719fcf5ef2aSThomas Huth 2720fcf5ef2aSThomas Huth return cr; 2721fcf5ef2aSThomas Huth } 2722fcf5ef2aSThomas Huth 2723fcf5ef2aSThomas Huth uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2724fcf5ef2aSThomas Huth { 2725fcf5ef2aSThomas Huth int i; 2726fcf5ef2aSThomas Huth int cr = 0; 2727fcf5ef2aSThomas Huth int invalid = 0; 2728fcf5ef2aSThomas Huth int zone_digit = 0; 2729fcf5ef2aSThomas Huth int zone_lead = ps ? 0xF : 0x3; 2730fcf5ef2aSThomas Huth int digit = 0; 2731fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2732fcf5ef2aSThomas Huth int sgnb = b->u8[BCD_DIG_BYTE(0)] >> 4; 2733fcf5ef2aSThomas Huth 2734fcf5ef2aSThomas Huth if (unlikely((sgnb < 0xA) && ps)) { 2735fcf5ef2aSThomas Huth invalid = 1; 2736fcf5ef2aSThomas Huth } 2737fcf5ef2aSThomas Huth 2738fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2739365206aeSJose Ricardo Ziviani zone_digit = i ? b->u8[BCD_DIG_BYTE(i * 2)] >> 4 : zone_lead; 2740fcf5ef2aSThomas Huth digit = b->u8[BCD_DIG_BYTE(i * 2)] & 0xF; 2741fcf5ef2aSThomas Huth if (unlikely(zone_digit != zone_lead || digit > 0x9)) { 2742fcf5ef2aSThomas Huth invalid = 1; 2743fcf5ef2aSThomas Huth break; 2744fcf5ef2aSThomas Huth } 2745fcf5ef2aSThomas Huth 2746fcf5ef2aSThomas Huth bcd_put_digit(&ret, digit, i + 1); 2747fcf5ef2aSThomas Huth } 2748fcf5ef2aSThomas Huth 2749fcf5ef2aSThomas Huth if ((ps && (sgnb == 0xB || sgnb == 0xD)) || 2750fcf5ef2aSThomas Huth (!ps && (sgnb & 0x4))) { 2751fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2752fcf5ef2aSThomas Huth } else { 2753fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0); 2754fcf5ef2aSThomas Huth } 2755fcf5ef2aSThomas Huth 2756fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2757fcf5ef2aSThomas Huth 2758fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2759efa73196SNikunj A Dadhania cr = CRF_SO; 2760fcf5ef2aSThomas Huth } 2761fcf5ef2aSThomas Huth 2762fcf5ef2aSThomas Huth *r = ret; 2763fcf5ef2aSThomas Huth 2764fcf5ef2aSThomas Huth return cr; 2765fcf5ef2aSThomas Huth } 2766fcf5ef2aSThomas Huth 2767fcf5ef2aSThomas Huth uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2768fcf5ef2aSThomas Huth { 2769fcf5ef2aSThomas Huth int i; 2770fcf5ef2aSThomas Huth int cr = 0; 2771fcf5ef2aSThomas Huth uint8_t digit = 0; 2772fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2773fcf5ef2aSThomas Huth int zone_lead = (ps) ? 0xF0 : 0x30; 2774fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2775fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2776fcf5ef2aSThomas Huth 27773c385a93SMark Cave-Ayland int ox_flag = ((b->VsrD(0) >> 4) != 0); 2778fcf5ef2aSThomas Huth 2779fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2780fcf5ef2aSThomas Huth digit = bcd_get_digit(b, i + 1, &invalid); 2781fcf5ef2aSThomas Huth 2782fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2783fcf5ef2aSThomas Huth break; 2784fcf5ef2aSThomas Huth } 2785fcf5ef2aSThomas Huth 2786fcf5ef2aSThomas Huth ret.u8[BCD_DIG_BYTE(i * 2)] = zone_lead + digit; 2787fcf5ef2aSThomas Huth } 2788fcf5ef2aSThomas Huth 2789fcf5ef2aSThomas Huth if (ps) { 2790fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1); 2791fcf5ef2aSThomas Huth } else { 2792fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1); 2793fcf5ef2aSThomas Huth } 2794fcf5ef2aSThomas Huth 2795fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2796fcf5ef2aSThomas Huth 2797fcf5ef2aSThomas Huth if (ox_flag) { 2798efa73196SNikunj A Dadhania cr |= CRF_SO; 2799fcf5ef2aSThomas Huth } 2800fcf5ef2aSThomas Huth 2801fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2802efa73196SNikunj A Dadhania cr = CRF_SO; 2803fcf5ef2aSThomas Huth } 2804fcf5ef2aSThomas Huth 2805fcf5ef2aSThomas Huth *r = ret; 2806fcf5ef2aSThomas Huth 2807fcf5ef2aSThomas Huth return cr; 2808fcf5ef2aSThomas Huth } 2809fcf5ef2aSThomas Huth 2810a406c058SJose Ricardo Ziviani uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2811a406c058SJose Ricardo Ziviani { 2812a406c058SJose Ricardo Ziviani int i; 2813a406c058SJose Ricardo Ziviani int cr = 0; 2814a406c058SJose Ricardo Ziviani uint64_t lo_value; 2815a406c058SJose Ricardo Ziviani uint64_t hi_value; 2816a406c058SJose Ricardo Ziviani ppc_avr_t ret = { .u64 = { 0, 0 } }; 2817a406c058SJose Ricardo Ziviani 28183c385a93SMark Cave-Ayland if (b->VsrSD(0) < 0) { 28193c385a93SMark Cave-Ayland lo_value = -b->VsrSD(1); 28203c385a93SMark Cave-Ayland hi_value = ~b->VsrD(0) + !lo_value; 2821a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, 0xD, 0); 2822a406c058SJose Ricardo Ziviani } else { 28233c385a93SMark Cave-Ayland lo_value = b->VsrD(1); 28243c385a93SMark Cave-Ayland hi_value = b->VsrD(0); 2825a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0); 2826a406c058SJose Ricardo Ziviani } 2827a406c058SJose Ricardo Ziviani 2828a406c058SJose Ricardo Ziviani if (divu128(&lo_value, &hi_value, 1000000000000000ULL) || 2829a406c058SJose Ricardo Ziviani lo_value > 9999999999999999ULL) { 2830a406c058SJose Ricardo Ziviani cr = CRF_SO; 2831a406c058SJose Ricardo Ziviani } 2832a406c058SJose Ricardo Ziviani 2833a406c058SJose Ricardo Ziviani for (i = 1; i < 16; hi_value /= 10, i++) { 2834a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, hi_value % 10, i); 2835a406c058SJose Ricardo Ziviani } 2836a406c058SJose Ricardo Ziviani 2837a406c058SJose Ricardo Ziviani for (; i < 32; lo_value /= 10, i++) { 2838a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, lo_value % 10, i); 2839a406c058SJose Ricardo Ziviani } 2840a406c058SJose Ricardo Ziviani 2841a406c058SJose Ricardo Ziviani cr |= bcd_cmp_zero(&ret); 2842a406c058SJose Ricardo Ziviani 2843a406c058SJose Ricardo Ziviani *r = ret; 2844a406c058SJose Ricardo Ziviani 2845a406c058SJose Ricardo Ziviani return cr; 2846a406c058SJose Ricardo Ziviani } 2847a406c058SJose Ricardo Ziviani 2848c85bc7ddSJose Ricardo Ziviani uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2849c85bc7ddSJose Ricardo Ziviani { 2850c85bc7ddSJose Ricardo Ziviani uint8_t i; 2851c85bc7ddSJose Ricardo Ziviani int cr; 2852c85bc7ddSJose Ricardo Ziviani uint64_t carry; 2853c85bc7ddSJose Ricardo Ziviani uint64_t unused; 2854c85bc7ddSJose Ricardo Ziviani uint64_t lo_value; 2855c85bc7ddSJose Ricardo Ziviani uint64_t hi_value = 0; 2856c85bc7ddSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2857c85bc7ddSJose Ricardo Ziviani int invalid = (sgnb == 0); 2858c85bc7ddSJose Ricardo Ziviani 2859c85bc7ddSJose Ricardo Ziviani lo_value = bcd_get_digit(b, 31, &invalid); 2860c85bc7ddSJose Ricardo Ziviani for (i = 30; i > 0; i--) { 2861c85bc7ddSJose Ricardo Ziviani mulu64(&lo_value, &carry, lo_value, 10ULL); 2862c85bc7ddSJose Ricardo Ziviani mulu64(&hi_value, &unused, hi_value, 10ULL); 2863c85bc7ddSJose Ricardo Ziviani lo_value += bcd_get_digit(b, i, &invalid); 2864c85bc7ddSJose Ricardo Ziviani hi_value += carry; 2865c85bc7ddSJose Ricardo Ziviani 2866c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2867c85bc7ddSJose Ricardo Ziviani break; 2868c85bc7ddSJose Ricardo Ziviani } 2869c85bc7ddSJose Ricardo Ziviani } 2870c85bc7ddSJose Ricardo Ziviani 2871c85bc7ddSJose Ricardo Ziviani if (sgnb == -1) { 28723c385a93SMark Cave-Ayland r->VsrSD(1) = -lo_value; 28733c385a93SMark Cave-Ayland r->VsrSD(0) = ~hi_value + !r->VsrSD(1); 2874c85bc7ddSJose Ricardo Ziviani } else { 28753c385a93SMark Cave-Ayland r->VsrSD(1) = lo_value; 28763c385a93SMark Cave-Ayland r->VsrSD(0) = hi_value; 2877c85bc7ddSJose Ricardo Ziviani } 2878c85bc7ddSJose Ricardo Ziviani 2879c85bc7ddSJose Ricardo Ziviani cr = bcd_cmp_zero(b); 2880c85bc7ddSJose Ricardo Ziviani 2881c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2882c85bc7ddSJose Ricardo Ziviani cr = CRF_SO; 2883c85bc7ddSJose Ricardo Ziviani } 2884c85bc7ddSJose Ricardo Ziviani 2885c85bc7ddSJose Ricardo Ziviani return cr; 2886c85bc7ddSJose Ricardo Ziviani } 2887c85bc7ddSJose Ricardo Ziviani 2888c3025c3bSJose Ricardo Ziviani uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2889c3025c3bSJose Ricardo Ziviani { 2890c3025c3bSJose Ricardo Ziviani int i; 2891c3025c3bSJose Ricardo Ziviani int invalid = 0; 2892c3025c3bSJose Ricardo Ziviani 2893c3025c3bSJose Ricardo Ziviani if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) { 2894c3025c3bSJose Ricardo Ziviani return CRF_SO; 2895c3025c3bSJose Ricardo Ziviani } 2896c3025c3bSJose Ricardo Ziviani 2897c3025c3bSJose Ricardo Ziviani *r = *a; 2898c3025c3bSJose Ricardo Ziviani bcd_put_digit(r, b->u8[BCD_DIG_BYTE(0)] & 0xF, 0); 2899c3025c3bSJose Ricardo Ziviani 2900c3025c3bSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2901c3025c3bSJose Ricardo Ziviani bcd_get_digit(a, i, &invalid); 2902c3025c3bSJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2903c3025c3bSJose Ricardo Ziviani if (unlikely(invalid)) { 2904c3025c3bSJose Ricardo Ziviani return CRF_SO; 2905c3025c3bSJose Ricardo Ziviani } 2906c3025c3bSJose Ricardo Ziviani } 2907c3025c3bSJose Ricardo Ziviani 2908c3025c3bSJose Ricardo Ziviani return bcd_cmp_zero(r); 2909c3025c3bSJose Ricardo Ziviani } 2910c3025c3bSJose Ricardo Ziviani 2911466a3f9cSJose Ricardo Ziviani uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2912466a3f9cSJose Ricardo Ziviani { 2913466a3f9cSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2914466a3f9cSJose Ricardo Ziviani 2915466a3f9cSJose Ricardo Ziviani *r = *b; 2916466a3f9cSJose Ricardo Ziviani bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0); 2917466a3f9cSJose Ricardo Ziviani 2918071663dfSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2919466a3f9cSJose Ricardo Ziviani return CRF_SO; 2920466a3f9cSJose Ricardo Ziviani } 2921466a3f9cSJose Ricardo Ziviani 2922466a3f9cSJose Ricardo Ziviani return bcd_cmp_zero(r); 2923466a3f9cSJose Ricardo Ziviani } 2924466a3f9cSJose Ricardo Ziviani 2925e04797f7SJose Ricardo Ziviani uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2926e04797f7SJose Ricardo Ziviani { 2927e04797f7SJose Ricardo Ziviani int cr; 2928e04797f7SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 2929e04797f7SJose Ricardo Ziviani int i = a->s8[7]; 2930e04797f7SJose Ricardo Ziviani #else 2931e04797f7SJose Ricardo Ziviani int i = a->s8[8]; 2932e04797f7SJose Ricardo Ziviani #endif 2933e04797f7SJose Ricardo Ziviani bool ox_flag = false; 2934e04797f7SJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2935e04797f7SJose Ricardo Ziviani ppc_avr_t ret = *b; 29363c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2937e04797f7SJose Ricardo Ziviani 2938e04797f7SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2939e04797f7SJose Ricardo Ziviani return CRF_SO; 2940e04797f7SJose Ricardo Ziviani } 2941e04797f7SJose Ricardo Ziviani 2942e04797f7SJose Ricardo Ziviani if (unlikely(i > 31)) { 2943e04797f7SJose Ricardo Ziviani i = 31; 2944e04797f7SJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2945e04797f7SJose Ricardo Ziviani i = -31; 2946e04797f7SJose Ricardo Ziviani } 2947e04797f7SJose Ricardo Ziviani 2948e04797f7SJose Ricardo Ziviani if (i > 0) { 29493c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2950e04797f7SJose Ricardo Ziviani } else { 29513c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2952e04797f7SJose Ricardo Ziviani } 2953e04797f7SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2954e04797f7SJose Ricardo Ziviani 2955e04797f7SJose Ricardo Ziviani *r = ret; 2956e04797f7SJose Ricardo Ziviani 2957e04797f7SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2958e04797f7SJose Ricardo Ziviani if (ox_flag) { 2959e04797f7SJose Ricardo Ziviani cr |= CRF_SO; 2960e04797f7SJose Ricardo Ziviani } 2961e04797f7SJose Ricardo Ziviani 2962e04797f7SJose Ricardo Ziviani return cr; 2963e04797f7SJose Ricardo Ziviani } 2964e04797f7SJose Ricardo Ziviani 2965a49a95e9SJose Ricardo Ziviani uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2966a49a95e9SJose Ricardo Ziviani { 2967a49a95e9SJose Ricardo Ziviani int cr; 2968a49a95e9SJose Ricardo Ziviani int i; 2969a49a95e9SJose Ricardo Ziviani int invalid = 0; 2970a49a95e9SJose Ricardo Ziviani bool ox_flag = false; 2971a49a95e9SJose Ricardo Ziviani ppc_avr_t ret = *b; 2972a49a95e9SJose Ricardo Ziviani 2973a49a95e9SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 2974a49a95e9SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2975a49a95e9SJose Ricardo Ziviani 2976a49a95e9SJose Ricardo Ziviani if (unlikely(invalid)) { 2977a49a95e9SJose Ricardo Ziviani return CRF_SO; 2978a49a95e9SJose Ricardo Ziviani } 2979a49a95e9SJose Ricardo Ziviani } 2980a49a95e9SJose Ricardo Ziviani 2981a49a95e9SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 2982a49a95e9SJose Ricardo Ziviani i = a->s8[7]; 2983a49a95e9SJose Ricardo Ziviani #else 2984a49a95e9SJose Ricardo Ziviani i = a->s8[8]; 2985a49a95e9SJose Ricardo Ziviani #endif 2986a49a95e9SJose Ricardo Ziviani if (i >= 32) { 2987a49a95e9SJose Ricardo Ziviani ox_flag = true; 29883c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2989a49a95e9SJose Ricardo Ziviani } else if (i <= -32) { 29903c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2991a49a95e9SJose Ricardo Ziviani } else if (i > 0) { 29923c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2993a49a95e9SJose Ricardo Ziviani } else { 29943c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2995a49a95e9SJose Ricardo Ziviani } 2996a49a95e9SJose Ricardo Ziviani *r = ret; 2997a49a95e9SJose Ricardo Ziviani 2998a49a95e9SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2999a49a95e9SJose Ricardo Ziviani if (ox_flag) { 3000a49a95e9SJose Ricardo Ziviani cr |= CRF_SO; 3001a49a95e9SJose Ricardo Ziviani } 3002a49a95e9SJose Ricardo Ziviani 3003a49a95e9SJose Ricardo Ziviani return cr; 3004a49a95e9SJose Ricardo Ziviani } 3005a49a95e9SJose Ricardo Ziviani 3006a54238adSJose Ricardo Ziviani uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 3007a54238adSJose Ricardo Ziviani { 3008a54238adSJose Ricardo Ziviani int cr; 3009a54238adSJose Ricardo Ziviani int unused = 0; 3010a54238adSJose Ricardo Ziviani int invalid = 0; 3011a54238adSJose Ricardo Ziviani bool ox_flag = false; 3012a54238adSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 3013a54238adSJose Ricardo Ziviani ppc_avr_t ret = *b; 30143c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 3015a54238adSJose Ricardo Ziviani 3016a54238adSJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 3017a54238adSJose Ricardo Ziviani int i = a->s8[7]; 3018a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0, 0x10 } }; 3019a54238adSJose Ricardo Ziviani #else 3020a54238adSJose Ricardo Ziviani int i = a->s8[8]; 3021a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0x10, 0 } }; 3022a54238adSJose Ricardo Ziviani #endif 3023a54238adSJose Ricardo Ziviani 3024a54238adSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 3025a54238adSJose Ricardo Ziviani return CRF_SO; 3026a54238adSJose Ricardo Ziviani } 3027a54238adSJose Ricardo Ziviani 3028a54238adSJose Ricardo Ziviani if (unlikely(i > 31)) { 3029a54238adSJose Ricardo Ziviani i = 31; 3030a54238adSJose Ricardo Ziviani } else if (unlikely(i < -31)) { 3031a54238adSJose Ricardo Ziviani i = -31; 3032a54238adSJose Ricardo Ziviani } 3033a54238adSJose Ricardo Ziviani 3034a54238adSJose Ricardo Ziviani if (i > 0) { 30353c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 3036a54238adSJose Ricardo Ziviani } else { 30373c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 3038a54238adSJose Ricardo Ziviani 3039a54238adSJose Ricardo Ziviani if (bcd_get_digit(&ret, 0, &invalid) >= 5) { 3040a54238adSJose Ricardo Ziviani bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused); 3041a54238adSJose Ricardo Ziviani } 3042a54238adSJose Ricardo Ziviani } 3043a54238adSJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 3044a54238adSJose Ricardo Ziviani 3045a54238adSJose Ricardo Ziviani cr = bcd_cmp_zero(&ret); 3046a54238adSJose Ricardo Ziviani if (ox_flag) { 3047a54238adSJose Ricardo Ziviani cr |= CRF_SO; 3048a54238adSJose Ricardo Ziviani } 3049a54238adSJose Ricardo Ziviani *r = ret; 3050a54238adSJose Ricardo Ziviani 3051a54238adSJose Ricardo Ziviani return cr; 3052a54238adSJose Ricardo Ziviani } 3053a54238adSJose Ricardo Ziviani 305431bc4d11SJose Ricardo Ziviani uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 305531bc4d11SJose Ricardo Ziviani { 305631bc4d11SJose Ricardo Ziviani uint64_t mask; 305731bc4d11SJose Ricardo Ziviani uint32_t ox_flag = 0; 305831bc4d11SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 305931bc4d11SJose Ricardo Ziviani int i = a->s16[3] + 1; 306031bc4d11SJose Ricardo Ziviani #else 306131bc4d11SJose Ricardo Ziviani int i = a->s16[4] + 1; 306231bc4d11SJose Ricardo Ziviani #endif 306331bc4d11SJose Ricardo Ziviani ppc_avr_t ret = *b; 306431bc4d11SJose Ricardo Ziviani 306531bc4d11SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 306631bc4d11SJose Ricardo Ziviani return CRF_SO; 306731bc4d11SJose Ricardo Ziviani } 306831bc4d11SJose Ricardo Ziviani 306931bc4d11SJose Ricardo Ziviani if (i > 16 && i < 32) { 307031bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 30713c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 307231bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 307331bc4d11SJose Ricardo Ziviani } 307431bc4d11SJose Ricardo Ziviani 30753c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 307631bc4d11SJose Ricardo Ziviani } else if (i >= 0 && i <= 16) { 307731bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 30783c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 307931bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 308031bc4d11SJose Ricardo Ziviani } 308131bc4d11SJose Ricardo Ziviani 30823c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 30833c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 308431bc4d11SJose Ricardo Ziviani } 308531bc4d11SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0); 308631bc4d11SJose Ricardo Ziviani *r = ret; 308731bc4d11SJose Ricardo Ziviani 308831bc4d11SJose Ricardo Ziviani return bcd_cmp_zero(&ret) | ox_flag; 308931bc4d11SJose Ricardo Ziviani } 309031bc4d11SJose Ricardo Ziviani 30915c32e2e4SJose Ricardo Ziviani uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 30925c32e2e4SJose Ricardo Ziviani { 30935c32e2e4SJose Ricardo Ziviani int i; 30945c32e2e4SJose Ricardo Ziviani uint64_t mask; 30955c32e2e4SJose Ricardo Ziviani uint32_t ox_flag = 0; 30965c32e2e4SJose Ricardo Ziviani int invalid = 0; 30975c32e2e4SJose Ricardo Ziviani ppc_avr_t ret = *b; 30985c32e2e4SJose Ricardo Ziviani 30995c32e2e4SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 31005c32e2e4SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 31015c32e2e4SJose Ricardo Ziviani 31025c32e2e4SJose Ricardo Ziviani if (unlikely(invalid)) { 31035c32e2e4SJose Ricardo Ziviani return CRF_SO; 31045c32e2e4SJose Ricardo Ziviani } 31055c32e2e4SJose Ricardo Ziviani } 31065c32e2e4SJose Ricardo Ziviani 31075c32e2e4SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 31085c32e2e4SJose Ricardo Ziviani i = a->s16[3]; 31095c32e2e4SJose Ricardo Ziviani #else 31105c32e2e4SJose Ricardo Ziviani i = a->s16[4]; 31115c32e2e4SJose Ricardo Ziviani #endif 31125c32e2e4SJose Ricardo Ziviani if (i > 16 && i < 33) { 31135c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 31143c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 31155c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 31165c32e2e4SJose Ricardo Ziviani } 31175c32e2e4SJose Ricardo Ziviani 31183c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 31195c32e2e4SJose Ricardo Ziviani } else if (i > 0 && i <= 16) { 31205c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 31213c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 31225c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 31235c32e2e4SJose Ricardo Ziviani } 31245c32e2e4SJose Ricardo Ziviani 31253c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 31263c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 31275c32e2e4SJose Ricardo Ziviani } else if (i == 0) { 31283c385a93SMark Cave-Ayland if (ret.VsrD(0) || ret.VsrD(1)) { 31295c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 31305c32e2e4SJose Ricardo Ziviani } 31313c385a93SMark Cave-Ayland ret.VsrD(0) = ret.VsrD(1) = 0; 31325c32e2e4SJose Ricardo Ziviani } 31335c32e2e4SJose Ricardo Ziviani 31345c32e2e4SJose Ricardo Ziviani *r = ret; 31353c385a93SMark Cave-Ayland if (r->VsrD(0) == 0 && r->VsrD(1) == 0) { 31365c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_EQ; 31375c32e2e4SJose Ricardo Ziviani } 31385c32e2e4SJose Ricardo Ziviani 31395c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_GT; 31405c32e2e4SJose Ricardo Ziviani } 31415c32e2e4SJose Ricardo Ziviani 3142fcf5ef2aSThomas Huth void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a) 3143fcf5ef2aSThomas Huth { 3144fcf5ef2aSThomas Huth int i; 3145fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3146fcf5ef2aSThomas Huth r->u8[i] = AES_sbox[a->u8[i]]; 3147fcf5ef2aSThomas Huth } 3148fcf5ef2aSThomas Huth } 3149fcf5ef2aSThomas Huth 3150fcf5ef2aSThomas Huth void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3151fcf5ef2aSThomas Huth { 3152fcf5ef2aSThomas Huth ppc_avr_t result; 3153fcf5ef2aSThomas Huth int i; 3154fcf5ef2aSThomas Huth 3155fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 31562dea57dbSMark Cave-Ayland result.VsrW(i) = b->VsrW(i) ^ 31572dea57dbSMark Cave-Ayland (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^ 31582dea57dbSMark Cave-Ayland AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^ 31592dea57dbSMark Cave-Ayland AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^ 31602dea57dbSMark Cave-Ayland AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]); 3161fcf5ef2aSThomas Huth } 3162fcf5ef2aSThomas Huth *r = result; 3163fcf5ef2aSThomas Huth } 3164fcf5ef2aSThomas Huth 3165fcf5ef2aSThomas Huth void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3166fcf5ef2aSThomas Huth { 3167fcf5ef2aSThomas Huth ppc_avr_t result; 3168fcf5ef2aSThomas Huth int i; 3169fcf5ef2aSThomas Huth 3170fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 31712dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]); 3172fcf5ef2aSThomas Huth } 3173fcf5ef2aSThomas Huth *r = result; 3174fcf5ef2aSThomas Huth } 3175fcf5ef2aSThomas Huth 3176fcf5ef2aSThomas Huth void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3177fcf5ef2aSThomas Huth { 3178fcf5ef2aSThomas Huth /* This differs from what is written in ISA V2.07. The RTL is */ 3179fcf5ef2aSThomas Huth /* incorrect and will be fixed in V2.07B. */ 3180fcf5ef2aSThomas Huth int i; 3181fcf5ef2aSThomas Huth ppc_avr_t tmp; 3182fcf5ef2aSThomas Huth 3183fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 31842dea57dbSMark Cave-Ayland tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])]; 3185fcf5ef2aSThomas Huth } 3186fcf5ef2aSThomas Huth 3187fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 31882dea57dbSMark Cave-Ayland r->VsrW(i) = 31892dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 0)][0] ^ 31902dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 1)][1] ^ 31912dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 2)][2] ^ 31922dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 3)][3]; 3193fcf5ef2aSThomas Huth } 3194fcf5ef2aSThomas Huth } 3195fcf5ef2aSThomas Huth 3196fcf5ef2aSThomas Huth void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3197fcf5ef2aSThomas Huth { 3198fcf5ef2aSThomas Huth ppc_avr_t result; 3199fcf5ef2aSThomas Huth int i; 3200fcf5ef2aSThomas Huth 3201fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 32022dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]); 3203fcf5ef2aSThomas Huth } 3204fcf5ef2aSThomas Huth *r = result; 3205fcf5ef2aSThomas Huth } 3206fcf5ef2aSThomas Huth 3207fcf5ef2aSThomas Huth void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3208fcf5ef2aSThomas Huth { 3209fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3210fcf5ef2aSThomas Huth int six = st_six & 0xF; 3211fcf5ef2aSThomas Huth int i; 3212fcf5ef2aSThomas Huth 3213730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 3214fcf5ef2aSThomas Huth if (st == 0) { 3215fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 32160ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 7) ^ 32170ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 18) ^ 3218730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 3); 3219fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 32200ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 17) ^ 32210ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 19) ^ 3222730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 10); 3223fcf5ef2aSThomas Huth } 3224fcf5ef2aSThomas Huth } else { /* st == 1 */ 3225fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 32260ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 2) ^ 32270ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 13) ^ 32280ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 22); 3229fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 32300ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 6) ^ 32310ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 11) ^ 32320ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 25); 3233fcf5ef2aSThomas Huth } 3234fcf5ef2aSThomas Huth } 3235fcf5ef2aSThomas Huth } 3236fcf5ef2aSThomas Huth } 3237fcf5ef2aSThomas Huth 3238fcf5ef2aSThomas Huth void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3239fcf5ef2aSThomas Huth { 3240fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3241fcf5ef2aSThomas Huth int six = st_six & 0xF; 3242fcf5ef2aSThomas Huth int i; 3243fcf5ef2aSThomas Huth 3244730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 3245fcf5ef2aSThomas Huth if (st == 0) { 3246fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 32470ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 1) ^ 32480ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 8) ^ 3249730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 7); 3250fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 32510ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 19) ^ 32520ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 61) ^ 3253730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 6); 3254fcf5ef2aSThomas Huth } 3255fcf5ef2aSThomas Huth } else { /* st == 1 */ 3256fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 32570ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 28) ^ 32580ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 34) ^ 32590ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 39); 3260fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 32610ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 14) ^ 32620ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 18) ^ 32630ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 41); 3264fcf5ef2aSThomas Huth } 3265fcf5ef2aSThomas Huth } 3266fcf5ef2aSThomas Huth } 3267fcf5ef2aSThomas Huth } 3268fcf5ef2aSThomas Huth 3269fcf5ef2aSThomas Huth void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 3270fcf5ef2aSThomas Huth { 3271fcf5ef2aSThomas Huth ppc_avr_t result; 3272fcf5ef2aSThomas Huth int i; 3273fcf5ef2aSThomas Huth 327460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 327560594feaSMark Cave-Ayland int indexA = c->VsrB(i) >> 4; 327660594feaSMark Cave-Ayland int indexB = c->VsrB(i) & 0xF; 327760594feaSMark Cave-Ayland 327860594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB); 3279fcf5ef2aSThomas Huth } 3280fcf5ef2aSThomas Huth *r = result; 3281fcf5ef2aSThomas Huth } 3282fcf5ef2aSThomas Huth 3283fcf5ef2aSThomas Huth #undef VECTOR_FOR_INORDER_I 3284fcf5ef2aSThomas Huth 3285fcf5ef2aSThomas Huth /*****************************************************************************/ 3286fcf5ef2aSThomas Huth /* SPE extension helpers */ 3287fcf5ef2aSThomas Huth /* Use a table to make this quicker */ 3288fcf5ef2aSThomas Huth static const uint8_t hbrev[16] = { 3289fcf5ef2aSThomas Huth 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 3290fcf5ef2aSThomas Huth 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, 3291fcf5ef2aSThomas Huth }; 3292fcf5ef2aSThomas Huth 3293fcf5ef2aSThomas Huth static inline uint8_t byte_reverse(uint8_t val) 3294fcf5ef2aSThomas Huth { 3295fcf5ef2aSThomas Huth return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); 3296fcf5ef2aSThomas Huth } 3297fcf5ef2aSThomas Huth 3298fcf5ef2aSThomas Huth static inline uint32_t word_reverse(uint32_t val) 3299fcf5ef2aSThomas Huth { 3300fcf5ef2aSThomas Huth return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | 3301fcf5ef2aSThomas Huth (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); 3302fcf5ef2aSThomas Huth } 3303fcf5ef2aSThomas Huth 3304fcf5ef2aSThomas Huth #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */ 3305fcf5ef2aSThomas Huth target_ulong helper_brinc(target_ulong arg1, target_ulong arg2) 3306fcf5ef2aSThomas Huth { 3307fcf5ef2aSThomas Huth uint32_t a, b, d, mask; 3308fcf5ef2aSThomas Huth 3309fcf5ef2aSThomas Huth mask = UINT32_MAX >> (32 - MASKBITS); 3310fcf5ef2aSThomas Huth a = arg1 & mask; 3311fcf5ef2aSThomas Huth b = arg2 & mask; 3312fcf5ef2aSThomas Huth d = word_reverse(1 + word_reverse(a | ~b)); 3313fcf5ef2aSThomas Huth return (arg1 & ~mask) | (d & b); 3314fcf5ef2aSThomas Huth } 3315fcf5ef2aSThomas Huth 3316fcf5ef2aSThomas Huth uint32_t helper_cntlsw32(uint32_t val) 3317fcf5ef2aSThomas Huth { 3318fcf5ef2aSThomas Huth if (val & 0x80000000) { 3319fcf5ef2aSThomas Huth return clz32(~val); 3320fcf5ef2aSThomas Huth } else { 3321fcf5ef2aSThomas Huth return clz32(val); 3322fcf5ef2aSThomas Huth } 3323fcf5ef2aSThomas Huth } 3324fcf5ef2aSThomas Huth 3325fcf5ef2aSThomas Huth uint32_t helper_cntlzw32(uint32_t val) 3326fcf5ef2aSThomas Huth { 3327fcf5ef2aSThomas Huth return clz32(val); 3328fcf5ef2aSThomas Huth } 3329fcf5ef2aSThomas Huth 3330fcf5ef2aSThomas Huth /* 440 specific */ 3331fcf5ef2aSThomas Huth target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high, 3332fcf5ef2aSThomas Huth target_ulong low, uint32_t update_Rc) 3333fcf5ef2aSThomas Huth { 3334fcf5ef2aSThomas Huth target_ulong mask; 3335fcf5ef2aSThomas Huth int i; 3336fcf5ef2aSThomas Huth 3337fcf5ef2aSThomas Huth i = 1; 3338fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3339fcf5ef2aSThomas Huth if ((high & mask) == 0) { 3340fcf5ef2aSThomas Huth if (update_Rc) { 3341fcf5ef2aSThomas Huth env->crf[0] = 0x4; 3342fcf5ef2aSThomas Huth } 3343fcf5ef2aSThomas Huth goto done; 3344fcf5ef2aSThomas Huth } 3345fcf5ef2aSThomas Huth i++; 3346fcf5ef2aSThomas Huth } 3347fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3348fcf5ef2aSThomas Huth if ((low & mask) == 0) { 3349fcf5ef2aSThomas Huth if (update_Rc) { 3350fcf5ef2aSThomas Huth env->crf[0] = 0x8; 3351fcf5ef2aSThomas Huth } 3352fcf5ef2aSThomas Huth goto done; 3353fcf5ef2aSThomas Huth } 3354fcf5ef2aSThomas Huth i++; 3355fcf5ef2aSThomas Huth } 3356fcf5ef2aSThomas Huth i = 8; 3357fcf5ef2aSThomas Huth if (update_Rc) { 3358fcf5ef2aSThomas Huth env->crf[0] = 0x2; 3359fcf5ef2aSThomas Huth } 3360fcf5ef2aSThomas Huth done: 3361fcf5ef2aSThomas Huth env->xer = (env->xer & ~0x7F) | i; 3362fcf5ef2aSThomas Huth if (update_Rc) { 3363fcf5ef2aSThomas Huth env->crf[0] |= xer_so; 3364fcf5ef2aSThomas Huth } 3365fcf5ef2aSThomas Huth return i; 3366fcf5ef2aSThomas Huth } 3367