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 */ 19*db725815SMarkus Armbruster 20fcf5ef2aSThomas Huth #include "qemu/osdep.h" 21fcf5ef2aSThomas Huth #include "cpu.h" 22fcf5ef2aSThomas Huth #include "internal.h" 23fcf5ef2aSThomas Huth #include "qemu/host-utils.h" 24*db725815SMarkus Armbruster #include "qemu/main-loop.h" 25fcf5ef2aSThomas Huth #include "exec/helper-proto.h" 26fcf5ef2aSThomas Huth #include "crypto/aes.h" 2724f91e81SAlex Bennée #include "fpu/softfloat.h" 283f74b632SRichard Henderson #include "qapi/error.h" 293f74b632SRichard Henderson #include "qemu/guest-random.h" 30fcf5ef2aSThomas Huth 31fcf5ef2aSThomas Huth #include "helper_regs.h" 32fcf5ef2aSThomas Huth /*****************************************************************************/ 33fcf5ef2aSThomas Huth /* Fixed point operations helpers */ 34fcf5ef2aSThomas Huth 35f32899deSNikunj A Dadhania static inline void helper_update_ov_legacy(CPUPPCState *env, int ov) 36f32899deSNikunj A Dadhania { 37f32899deSNikunj A Dadhania if (unlikely(ov)) { 38f32899deSNikunj A Dadhania env->so = env->ov = 1; 39f32899deSNikunj A Dadhania } else { 40f32899deSNikunj A Dadhania env->ov = 0; 41f32899deSNikunj A Dadhania } 42f32899deSNikunj A Dadhania } 43f32899deSNikunj A Dadhania 44fcf5ef2aSThomas Huth target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb, 45fcf5ef2aSThomas Huth uint32_t oe) 46fcf5ef2aSThomas Huth { 47fcf5ef2aSThomas Huth uint64_t rt = 0; 48fcf5ef2aSThomas Huth int overflow = 0; 49fcf5ef2aSThomas Huth 50fcf5ef2aSThomas Huth uint64_t dividend = (uint64_t)ra << 32; 51fcf5ef2aSThomas Huth uint64_t divisor = (uint32_t)rb; 52fcf5ef2aSThomas Huth 53fcf5ef2aSThomas Huth if (unlikely(divisor == 0)) { 54fcf5ef2aSThomas Huth overflow = 1; 55fcf5ef2aSThomas Huth } else { 56fcf5ef2aSThomas Huth rt = dividend / divisor; 57fcf5ef2aSThomas Huth overflow = rt > UINT32_MAX; 58fcf5ef2aSThomas Huth } 59fcf5ef2aSThomas Huth 60fcf5ef2aSThomas Huth if (unlikely(overflow)) { 61fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 62fcf5ef2aSThomas Huth } 63fcf5ef2aSThomas Huth 64fcf5ef2aSThomas Huth if (oe) { 65f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 66fcf5ef2aSThomas Huth } 67fcf5ef2aSThomas Huth 68fcf5ef2aSThomas Huth return (target_ulong)rt; 69fcf5ef2aSThomas Huth } 70fcf5ef2aSThomas Huth 71fcf5ef2aSThomas Huth target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb, 72fcf5ef2aSThomas Huth uint32_t oe) 73fcf5ef2aSThomas Huth { 74fcf5ef2aSThomas Huth int64_t rt = 0; 75fcf5ef2aSThomas Huth int overflow = 0; 76fcf5ef2aSThomas Huth 77fcf5ef2aSThomas Huth int64_t dividend = (int64_t)ra << 32; 78fcf5ef2aSThomas Huth int64_t divisor = (int64_t)((int32_t)rb); 79fcf5ef2aSThomas Huth 80fcf5ef2aSThomas Huth if (unlikely((divisor == 0) || 81fcf5ef2aSThomas Huth ((divisor == -1ull) && (dividend == INT64_MIN)))) { 82fcf5ef2aSThomas Huth overflow = 1; 83fcf5ef2aSThomas Huth } else { 84fcf5ef2aSThomas Huth rt = dividend / divisor; 85fcf5ef2aSThomas Huth overflow = rt != (int32_t)rt; 86fcf5ef2aSThomas Huth } 87fcf5ef2aSThomas Huth 88fcf5ef2aSThomas Huth if (unlikely(overflow)) { 89fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 90fcf5ef2aSThomas Huth } 91fcf5ef2aSThomas Huth 92fcf5ef2aSThomas Huth if (oe) { 93f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 94fcf5ef2aSThomas Huth } 95fcf5ef2aSThomas Huth 96fcf5ef2aSThomas Huth return (target_ulong)rt; 97fcf5ef2aSThomas Huth } 98fcf5ef2aSThomas Huth 99fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 100fcf5ef2aSThomas Huth 101fcf5ef2aSThomas Huth uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe) 102fcf5ef2aSThomas Huth { 103fcf5ef2aSThomas Huth uint64_t rt = 0; 104fcf5ef2aSThomas Huth int overflow = 0; 105fcf5ef2aSThomas Huth 106fcf5ef2aSThomas Huth overflow = divu128(&rt, &ra, rb); 107fcf5ef2aSThomas Huth 108fcf5ef2aSThomas Huth if (unlikely(overflow)) { 109fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 110fcf5ef2aSThomas Huth } 111fcf5ef2aSThomas Huth 112fcf5ef2aSThomas Huth if (oe) { 113f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 114fcf5ef2aSThomas Huth } 115fcf5ef2aSThomas Huth 116fcf5ef2aSThomas Huth return rt; 117fcf5ef2aSThomas Huth } 118fcf5ef2aSThomas Huth 119fcf5ef2aSThomas Huth uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe) 120fcf5ef2aSThomas Huth { 121fcf5ef2aSThomas Huth int64_t rt = 0; 122fcf5ef2aSThomas Huth int64_t ra = (int64_t)rau; 123fcf5ef2aSThomas Huth int64_t rb = (int64_t)rbu; 124fcf5ef2aSThomas Huth int overflow = divs128(&rt, &ra, rb); 125fcf5ef2aSThomas Huth 126fcf5ef2aSThomas Huth if (unlikely(overflow)) { 127fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 128fcf5ef2aSThomas Huth } 129fcf5ef2aSThomas Huth 130fcf5ef2aSThomas Huth if (oe) { 131f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 132fcf5ef2aSThomas Huth } 133fcf5ef2aSThomas Huth 134fcf5ef2aSThomas Huth return rt; 135fcf5ef2aSThomas Huth } 136fcf5ef2aSThomas Huth 137fcf5ef2aSThomas Huth #endif 138fcf5ef2aSThomas Huth 139fcf5ef2aSThomas Huth 140fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 141fcf5ef2aSThomas Huth /* if x = 0xab, returns 0xababababababababa */ 142fcf5ef2aSThomas Huth #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff)) 143fcf5ef2aSThomas Huth 144b6cb41b2SDavid Gibson /* 145b6cb41b2SDavid Gibson * subtract 1 from each byte, and with inverse, check if MSB is set at each 146fcf5ef2aSThomas Huth * byte. 147fcf5ef2aSThomas Huth * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80 148fcf5ef2aSThomas Huth * (0xFF & 0xFF) & 0x80 = 0x80 (zero found) 149fcf5ef2aSThomas Huth */ 150fcf5ef2aSThomas Huth #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80)) 151fcf5ef2aSThomas Huth 152fcf5ef2aSThomas Huth /* When you XOR the pattern and there is a match, that byte will be zero */ 153fcf5ef2aSThomas Huth #define hasvalue(x, n) (haszero((x) ^ pattern(n))) 154fcf5ef2aSThomas Huth 155fcf5ef2aSThomas Huth uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) 156fcf5ef2aSThomas Huth { 157efa73196SNikunj A Dadhania return hasvalue(rb, ra) ? CRF_GT : 0; 158fcf5ef2aSThomas Huth } 159fcf5ef2aSThomas Huth 160fcf5ef2aSThomas Huth #undef pattern 161fcf5ef2aSThomas Huth #undef haszero 162fcf5ef2aSThomas Huth #undef hasvalue 163fcf5ef2aSThomas Huth 164b6cb41b2SDavid Gibson /* 1653f74b632SRichard Henderson * Return a random number. 166fcf5ef2aSThomas Huth */ 1673f74b632SRichard Henderson uint64_t helper_darn32(void) 168fcf5ef2aSThomas Huth { 1693f74b632SRichard Henderson Error *err = NULL; 1703f74b632SRichard Henderson uint32_t ret; 1713f74b632SRichard Henderson 1723f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1733f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1743f74b632SRichard Henderson error_get_pretty(err)); 1753f74b632SRichard Henderson error_free(err); 176fcf5ef2aSThomas Huth return -1; 177fcf5ef2aSThomas Huth } 178fcf5ef2aSThomas Huth 1793f74b632SRichard Henderson return ret; 1803f74b632SRichard Henderson } 1813f74b632SRichard Henderson 1823f74b632SRichard Henderson uint64_t helper_darn64(void) 183fcf5ef2aSThomas Huth { 1843f74b632SRichard Henderson Error *err = NULL; 1853f74b632SRichard Henderson uint64_t ret; 1863f74b632SRichard Henderson 1873f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1883f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1893f74b632SRichard Henderson error_get_pretty(err)); 1903f74b632SRichard Henderson error_free(err); 191fcf5ef2aSThomas Huth return -1; 192fcf5ef2aSThomas Huth } 193fcf5ef2aSThomas Huth 1943f74b632SRichard Henderson return ret; 1953f74b632SRichard Henderson } 196fcf5ef2aSThomas Huth 197fcf5ef2aSThomas Huth uint64_t helper_bpermd(uint64_t rs, uint64_t rb) 198fcf5ef2aSThomas Huth { 199fcf5ef2aSThomas Huth int i; 200fcf5ef2aSThomas Huth uint64_t ra = 0; 201fcf5ef2aSThomas Huth 202fcf5ef2aSThomas Huth for (i = 0; i < 8; i++) { 203fcf5ef2aSThomas Huth int index = (rs >> (i * 8)) & 0xFF; 204fcf5ef2aSThomas Huth if (index < 64) { 205a6a444a8SCédric Le Goater if (rb & PPC_BIT(index)) { 206fcf5ef2aSThomas Huth ra |= 1 << i; 207fcf5ef2aSThomas Huth } 208fcf5ef2aSThomas Huth } 209fcf5ef2aSThomas Huth } 210fcf5ef2aSThomas Huth return ra; 211fcf5ef2aSThomas Huth } 212fcf5ef2aSThomas Huth 213fcf5ef2aSThomas Huth #endif 214fcf5ef2aSThomas Huth 215fcf5ef2aSThomas Huth target_ulong helper_cmpb(target_ulong rs, target_ulong rb) 216fcf5ef2aSThomas Huth { 217fcf5ef2aSThomas Huth target_ulong mask = 0xff; 218fcf5ef2aSThomas Huth target_ulong ra = 0; 219fcf5ef2aSThomas Huth int i; 220fcf5ef2aSThomas Huth 221fcf5ef2aSThomas Huth for (i = 0; i < sizeof(target_ulong); i++) { 222fcf5ef2aSThomas Huth if ((rs & mask) == (rb & mask)) { 223fcf5ef2aSThomas Huth ra |= mask; 224fcf5ef2aSThomas Huth } 225fcf5ef2aSThomas Huth mask <<= 8; 226fcf5ef2aSThomas Huth } 227fcf5ef2aSThomas Huth return ra; 228fcf5ef2aSThomas Huth } 229fcf5ef2aSThomas Huth 230fcf5ef2aSThomas Huth /* shift right arithmetic helper */ 231fcf5ef2aSThomas Huth target_ulong helper_sraw(CPUPPCState *env, target_ulong value, 232fcf5ef2aSThomas Huth target_ulong shift) 233fcf5ef2aSThomas Huth { 234fcf5ef2aSThomas Huth int32_t ret; 235fcf5ef2aSThomas Huth 236fcf5ef2aSThomas Huth if (likely(!(shift & 0x20))) { 237fcf5ef2aSThomas Huth if (likely((uint32_t)shift != 0)) { 238fcf5ef2aSThomas Huth shift &= 0x1f; 239fcf5ef2aSThomas Huth ret = (int32_t)value >> shift; 240fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) { 241af1c259fSSandipan Das env->ca32 = env->ca = 0; 242fcf5ef2aSThomas Huth } else { 243af1c259fSSandipan Das env->ca32 = env->ca = 1; 244fcf5ef2aSThomas Huth } 245fcf5ef2aSThomas Huth } else { 246fcf5ef2aSThomas Huth ret = (int32_t)value; 247af1c259fSSandipan Das env->ca32 = env->ca = 0; 248fcf5ef2aSThomas Huth } 249fcf5ef2aSThomas Huth } else { 250fcf5ef2aSThomas Huth ret = (int32_t)value >> 31; 251af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 252fcf5ef2aSThomas Huth } 253fcf5ef2aSThomas Huth return (target_long)ret; 254fcf5ef2aSThomas Huth } 255fcf5ef2aSThomas Huth 256fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 257fcf5ef2aSThomas Huth target_ulong helper_srad(CPUPPCState *env, target_ulong value, 258fcf5ef2aSThomas Huth target_ulong shift) 259fcf5ef2aSThomas Huth { 260fcf5ef2aSThomas Huth int64_t ret; 261fcf5ef2aSThomas Huth 262fcf5ef2aSThomas Huth if (likely(!(shift & 0x40))) { 263fcf5ef2aSThomas Huth if (likely((uint64_t)shift != 0)) { 264fcf5ef2aSThomas Huth shift &= 0x3f; 265fcf5ef2aSThomas Huth ret = (int64_t)value >> shift; 266fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) { 267af1c259fSSandipan Das env->ca32 = env->ca = 0; 268fcf5ef2aSThomas Huth } else { 269af1c259fSSandipan Das env->ca32 = env->ca = 1; 270fcf5ef2aSThomas Huth } 271fcf5ef2aSThomas Huth } else { 272fcf5ef2aSThomas Huth ret = (int64_t)value; 273af1c259fSSandipan Das env->ca32 = env->ca = 0; 274fcf5ef2aSThomas Huth } 275fcf5ef2aSThomas Huth } else { 276fcf5ef2aSThomas Huth ret = (int64_t)value >> 63; 277af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 278fcf5ef2aSThomas Huth } 279fcf5ef2aSThomas Huth return ret; 280fcf5ef2aSThomas Huth } 281fcf5ef2aSThomas Huth #endif 282fcf5ef2aSThomas Huth 283fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 284fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 285fcf5ef2aSThomas Huth { 28679770002SRichard Henderson /* Note that we don't fold past bytes */ 287fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 288fcf5ef2aSThomas Huth 0x5555555555555555ULL); 289fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 290fcf5ef2aSThomas Huth 0x3333333333333333ULL); 291fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 292fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 293fcf5ef2aSThomas Huth return val; 294fcf5ef2aSThomas Huth } 295fcf5ef2aSThomas Huth 296fcf5ef2aSThomas Huth target_ulong helper_popcntw(target_ulong val) 297fcf5ef2aSThomas Huth { 29879770002SRichard Henderson /* Note that we don't fold past words. */ 299fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 300fcf5ef2aSThomas Huth 0x5555555555555555ULL); 301fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 302fcf5ef2aSThomas Huth 0x3333333333333333ULL); 303fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 304fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 305fcf5ef2aSThomas Huth val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 306fcf5ef2aSThomas Huth 0x00ff00ff00ff00ffULL); 307fcf5ef2aSThomas Huth val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 308fcf5ef2aSThomas Huth 0x0000ffff0000ffffULL); 309fcf5ef2aSThomas Huth return val; 310fcf5ef2aSThomas Huth } 311fcf5ef2aSThomas Huth #else 312fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 313fcf5ef2aSThomas Huth { 31479770002SRichard Henderson /* Note that we don't fold past bytes */ 315fcf5ef2aSThomas Huth val = (val & 0x55555555) + ((val >> 1) & 0x55555555); 316fcf5ef2aSThomas Huth val = (val & 0x33333333) + ((val >> 2) & 0x33333333); 317fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f); 318fcf5ef2aSThomas Huth return val; 319fcf5ef2aSThomas Huth } 320fcf5ef2aSThomas Huth #endif 321fcf5ef2aSThomas Huth 322fcf5ef2aSThomas Huth /*****************************************************************************/ 323fcf5ef2aSThomas Huth /* PowerPC 601 specific instructions (POWER bridge) */ 324fcf5ef2aSThomas Huth target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2) 325fcf5ef2aSThomas Huth { 326fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 327fcf5ef2aSThomas Huth 328fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 329fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 330fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 331fcf5ef2aSThomas Huth return INT32_MIN; 332fcf5ef2aSThomas Huth } else { 333fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 334fcf5ef2aSThomas Huth return tmp / (int32_t)arg2; 335fcf5ef2aSThomas Huth } 336fcf5ef2aSThomas Huth } 337fcf5ef2aSThomas Huth 338fcf5ef2aSThomas Huth target_ulong helper_divo(CPUPPCState *env, target_ulong arg1, 339fcf5ef2aSThomas Huth target_ulong arg2) 340fcf5ef2aSThomas Huth { 341fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 342fcf5ef2aSThomas Huth 343fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 344fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 345fcf5ef2aSThomas Huth env->so = env->ov = 1; 346fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 347fcf5ef2aSThomas Huth return INT32_MIN; 348fcf5ef2aSThomas Huth } else { 349fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 350fcf5ef2aSThomas Huth tmp /= (int32_t)arg2; 351fcf5ef2aSThomas Huth if ((int32_t)tmp != tmp) { 352fcf5ef2aSThomas Huth env->so = env->ov = 1; 353fcf5ef2aSThomas Huth } else { 354fcf5ef2aSThomas Huth env->ov = 0; 355fcf5ef2aSThomas Huth } 356fcf5ef2aSThomas Huth return tmp; 357fcf5ef2aSThomas Huth } 358fcf5ef2aSThomas Huth } 359fcf5ef2aSThomas Huth 360fcf5ef2aSThomas Huth target_ulong helper_divs(CPUPPCState *env, target_ulong arg1, 361fcf5ef2aSThomas Huth target_ulong arg2) 362fcf5ef2aSThomas Huth { 363fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 364fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 365fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 366fcf5ef2aSThomas Huth return INT32_MIN; 367fcf5ef2aSThomas Huth } else { 368fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 369fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 370fcf5ef2aSThomas Huth } 371fcf5ef2aSThomas Huth } 372fcf5ef2aSThomas Huth 373fcf5ef2aSThomas Huth target_ulong helper_divso(CPUPPCState *env, target_ulong arg1, 374fcf5ef2aSThomas Huth target_ulong arg2) 375fcf5ef2aSThomas Huth { 376fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 377fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 378fcf5ef2aSThomas Huth env->so = env->ov = 1; 379fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 380fcf5ef2aSThomas Huth return INT32_MIN; 381fcf5ef2aSThomas Huth } else { 382fcf5ef2aSThomas Huth env->ov = 0; 383fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 384fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 385fcf5ef2aSThomas Huth } 386fcf5ef2aSThomas Huth } 387fcf5ef2aSThomas Huth 388fcf5ef2aSThomas Huth /*****************************************************************************/ 389fcf5ef2aSThomas Huth /* 602 specific instructions */ 390fcf5ef2aSThomas Huth /* mfrom is the most crazy instruction ever seen, imho ! */ 391fcf5ef2aSThomas Huth /* Real implementation uses a ROM table. Do the same */ 392b6cb41b2SDavid Gibson /* 393b6cb41b2SDavid Gibson * Extremely decomposed: 394fcf5ef2aSThomas Huth * -arg / 256 395fcf5ef2aSThomas Huth * return 256 * log10(10 + 1.0) + 0.5 396fcf5ef2aSThomas Huth */ 397fcf5ef2aSThomas Huth #if !defined(CONFIG_USER_ONLY) 398fcf5ef2aSThomas Huth target_ulong helper_602_mfrom(target_ulong arg) 399fcf5ef2aSThomas Huth { 400fcf5ef2aSThomas Huth if (likely(arg < 602)) { 4015b27a92dSPaolo Bonzini #include "mfrom_table.inc.c" 402fcf5ef2aSThomas Huth return mfrom_ROM_table[arg]; 403fcf5ef2aSThomas Huth } else { 404fcf5ef2aSThomas Huth return 0; 405fcf5ef2aSThomas Huth } 406fcf5ef2aSThomas Huth } 407fcf5ef2aSThomas Huth #endif 408fcf5ef2aSThomas Huth 409fcf5ef2aSThomas Huth /*****************************************************************************/ 410fcf5ef2aSThomas Huth /* Altivec extension helpers */ 411fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 412fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 413fcf5ef2aSThomas Huth for (index = 0; index < ARRAY_SIZE(r->element); index++) 414fcf5ef2aSThomas Huth #else 415fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 416fcf5ef2aSThomas Huth for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--) 417fcf5ef2aSThomas Huth #endif 418fcf5ef2aSThomas Huth 419fcf5ef2aSThomas Huth /* Saturating arithmetic helpers. */ 420fcf5ef2aSThomas Huth #define SATCVT(from, to, from_type, to_type, min, max) \ 421fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 422fcf5ef2aSThomas Huth { \ 423fcf5ef2aSThomas Huth to_type r; \ 424fcf5ef2aSThomas Huth \ 425fcf5ef2aSThomas Huth if (x < (from_type)min) { \ 426fcf5ef2aSThomas Huth r = min; \ 427fcf5ef2aSThomas Huth *sat = 1; \ 428fcf5ef2aSThomas Huth } else if (x > (from_type)max) { \ 429fcf5ef2aSThomas Huth r = max; \ 430fcf5ef2aSThomas Huth *sat = 1; \ 431fcf5ef2aSThomas Huth } else { \ 432fcf5ef2aSThomas Huth r = x; \ 433fcf5ef2aSThomas Huth } \ 434fcf5ef2aSThomas Huth return r; \ 435fcf5ef2aSThomas Huth } 436fcf5ef2aSThomas Huth #define SATCVTU(from, to, from_type, to_type, min, max) \ 437fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 438fcf5ef2aSThomas Huth { \ 439fcf5ef2aSThomas Huth to_type r; \ 440fcf5ef2aSThomas Huth \ 441fcf5ef2aSThomas Huth if (x > (from_type)max) { \ 442fcf5ef2aSThomas Huth r = max; \ 443fcf5ef2aSThomas Huth *sat = 1; \ 444fcf5ef2aSThomas Huth } else { \ 445fcf5ef2aSThomas Huth r = x; \ 446fcf5ef2aSThomas Huth } \ 447fcf5ef2aSThomas Huth return r; \ 448fcf5ef2aSThomas Huth } 449fcf5ef2aSThomas Huth SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX) 450fcf5ef2aSThomas Huth SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX) 451fcf5ef2aSThomas Huth SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX) 452fcf5ef2aSThomas Huth 453fcf5ef2aSThomas Huth SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX) 454fcf5ef2aSThomas Huth SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX) 455fcf5ef2aSThomas Huth SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX) 456fcf5ef2aSThomas Huth SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX) 457fcf5ef2aSThomas Huth SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX) 458fcf5ef2aSThomas Huth SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX) 459fcf5ef2aSThomas Huth #undef SATCVT 460fcf5ef2aSThomas Huth #undef SATCVTU 461fcf5ef2aSThomas Huth 462fcf5ef2aSThomas Huth void helper_lvsl(ppc_avr_t *r, target_ulong sh) 463fcf5ef2aSThomas Huth { 464fcf5ef2aSThomas Huth int i, j = (sh & 0xf); 465fcf5ef2aSThomas Huth 46660594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 46760594feaSMark Cave-Ayland r->VsrB(i) = j++; 468fcf5ef2aSThomas Huth } 469fcf5ef2aSThomas Huth } 470fcf5ef2aSThomas Huth 471fcf5ef2aSThomas Huth void helper_lvsr(ppc_avr_t *r, target_ulong sh) 472fcf5ef2aSThomas Huth { 473fcf5ef2aSThomas Huth int i, j = 0x10 - (sh & 0xf); 474fcf5ef2aSThomas Huth 47560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 47660594feaSMark Cave-Ayland r->VsrB(i) = j++; 477fcf5ef2aSThomas Huth } 478fcf5ef2aSThomas Huth } 479fcf5ef2aSThomas Huth 480dedfaac7SRichard Henderson void helper_mtvscr(CPUPPCState *env, uint32_t vscr) 481fcf5ef2aSThomas Huth { 4829b5b74daSRichard Henderson env->vscr = vscr & ~(1u << VSCR_SAT); 4839b5b74daSRichard Henderson /* Which bit we set is completely arbitrary, but clear the rest. */ 4849b5b74daSRichard Henderson env->vscr_sat.u64[0] = vscr & (1u << VSCR_SAT); 4859b5b74daSRichard Henderson env->vscr_sat.u64[1] = 0; 486dedfaac7SRichard Henderson set_flush_to_zero((vscr >> VSCR_NJ) & 1, &env->vec_status); 487fcf5ef2aSThomas Huth } 488fcf5ef2aSThomas Huth 489cc2b90d7SRichard Henderson uint32_t helper_mfvscr(CPUPPCState *env) 490cc2b90d7SRichard Henderson { 4919b5b74daSRichard Henderson uint32_t sat = (env->vscr_sat.u64[0] | env->vscr_sat.u64[1]) != 0; 4929b5b74daSRichard Henderson return env->vscr | (sat << VSCR_SAT); 493cc2b90d7SRichard Henderson } 494cc2b90d7SRichard Henderson 4956175f5a0SRichard Henderson static inline void set_vscr_sat(CPUPPCState *env) 4966175f5a0SRichard Henderson { 4979b5b74daSRichard Henderson /* The choice of non-zero value is arbitrary. */ 4989b5b74daSRichard Henderson env->vscr_sat.u32[0] = 1; 4996175f5a0SRichard Henderson } 5006175f5a0SRichard Henderson 501fcf5ef2aSThomas Huth void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 502fcf5ef2aSThomas Huth { 503fcf5ef2aSThomas Huth int i; 504fcf5ef2aSThomas Huth 505fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 506fcf5ef2aSThomas Huth r->u32[i] = ~a->u32[i] < b->u32[i]; 507fcf5ef2aSThomas Huth } 508fcf5ef2aSThomas Huth } 509fcf5ef2aSThomas Huth 510fcf5ef2aSThomas Huth /* vprtybw */ 511fcf5ef2aSThomas Huth void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b) 512fcf5ef2aSThomas Huth { 513fcf5ef2aSThomas Huth int i; 514fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 515fcf5ef2aSThomas Huth uint64_t res = b->u32[i] ^ (b->u32[i] >> 16); 516fcf5ef2aSThomas Huth res ^= res >> 8; 517fcf5ef2aSThomas Huth r->u32[i] = res & 1; 518fcf5ef2aSThomas Huth } 519fcf5ef2aSThomas Huth } 520fcf5ef2aSThomas Huth 521fcf5ef2aSThomas Huth /* vprtybd */ 522fcf5ef2aSThomas Huth void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b) 523fcf5ef2aSThomas Huth { 524fcf5ef2aSThomas Huth int i; 525fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 526fcf5ef2aSThomas Huth uint64_t res = b->u64[i] ^ (b->u64[i] >> 32); 527fcf5ef2aSThomas Huth res ^= res >> 16; 528fcf5ef2aSThomas Huth res ^= res >> 8; 529fcf5ef2aSThomas Huth r->u64[i] = res & 1; 530fcf5ef2aSThomas Huth } 531fcf5ef2aSThomas Huth } 532fcf5ef2aSThomas Huth 533fcf5ef2aSThomas Huth /* vprtybq */ 534fcf5ef2aSThomas Huth void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b) 535fcf5ef2aSThomas Huth { 536fcf5ef2aSThomas Huth uint64_t res = b->u64[0] ^ b->u64[1]; 537fcf5ef2aSThomas Huth res ^= res >> 32; 538fcf5ef2aSThomas Huth res ^= res >> 16; 539fcf5ef2aSThomas Huth res ^= res >> 8; 5403c385a93SMark Cave-Ayland r->VsrD(1) = res & 1; 5413c385a93SMark Cave-Ayland r->VsrD(0) = 0; 542fcf5ef2aSThomas Huth } 543fcf5ef2aSThomas Huth 544fcf5ef2aSThomas Huth #define VARITH_DO(name, op, element) \ 545fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 546fcf5ef2aSThomas Huth { \ 547fcf5ef2aSThomas Huth int i; \ 548fcf5ef2aSThomas Huth \ 549fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 550fcf5ef2aSThomas Huth r->element[i] = a->element[i] op b->element[i]; \ 551fcf5ef2aSThomas Huth } \ 552fcf5ef2aSThomas Huth } 553fcf5ef2aSThomas Huth VARITH_DO(muluwm, *, u32) 554fcf5ef2aSThomas Huth #undef VARITH_DO 555fcf5ef2aSThomas Huth #undef VARITH 556fcf5ef2aSThomas Huth 557fcf5ef2aSThomas Huth #define VARITHFP(suffix, func) \ 558fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 559fcf5ef2aSThomas Huth ppc_avr_t *b) \ 560fcf5ef2aSThomas Huth { \ 561fcf5ef2aSThomas Huth int i; \ 562fcf5ef2aSThomas Huth \ 56305ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 56405ee3e8aSMark Cave-Ayland r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \ 565fcf5ef2aSThomas Huth } \ 566fcf5ef2aSThomas Huth } 567fcf5ef2aSThomas Huth VARITHFP(addfp, float32_add) 568fcf5ef2aSThomas Huth VARITHFP(subfp, float32_sub) 569fcf5ef2aSThomas Huth VARITHFP(minfp, float32_min) 570fcf5ef2aSThomas Huth VARITHFP(maxfp, float32_max) 571fcf5ef2aSThomas Huth #undef VARITHFP 572fcf5ef2aSThomas Huth 573fcf5ef2aSThomas Huth #define VARITHFPFMA(suffix, type) \ 574fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 575fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) \ 576fcf5ef2aSThomas Huth { \ 577fcf5ef2aSThomas Huth int i; \ 57805ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 57905ee3e8aSMark Cave-Ayland r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \ 580fcf5ef2aSThomas Huth type, &env->vec_status); \ 581fcf5ef2aSThomas Huth } \ 582fcf5ef2aSThomas Huth } 583fcf5ef2aSThomas Huth VARITHFPFMA(maddfp, 0); 584fcf5ef2aSThomas Huth VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c); 585fcf5ef2aSThomas Huth #undef VARITHFPFMA 586fcf5ef2aSThomas Huth 587fcf5ef2aSThomas Huth #define VARITHSAT_CASE(type, op, cvt, element) \ 588fcf5ef2aSThomas Huth { \ 589fcf5ef2aSThomas Huth type result = (type)a->element[i] op (type)b->element[i]; \ 590fcf5ef2aSThomas Huth r->element[i] = cvt(result, &sat); \ 591fcf5ef2aSThomas Huth } 592fcf5ef2aSThomas Huth 593fcf5ef2aSThomas Huth #define VARITHSAT_DO(name, op, optype, cvt, element) \ 594fb11ae7dSRichard Henderson void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat, \ 595fb11ae7dSRichard Henderson ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \ 596fcf5ef2aSThomas Huth { \ 597fcf5ef2aSThomas Huth int sat = 0; \ 598fcf5ef2aSThomas Huth int i; \ 599fcf5ef2aSThomas Huth \ 600fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 601fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 602fcf5ef2aSThomas Huth } \ 603fcf5ef2aSThomas Huth if (sat) { \ 604fb11ae7dSRichard Henderson vscr_sat->u32[0] = 1; \ 605fcf5ef2aSThomas Huth } \ 606fcf5ef2aSThomas Huth } 607fcf5ef2aSThomas Huth #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \ 608fcf5ef2aSThomas Huth VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \ 609fcf5ef2aSThomas Huth VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element) 610fcf5ef2aSThomas Huth #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \ 611fcf5ef2aSThomas Huth VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \ 612fcf5ef2aSThomas Huth VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element) 613fcf5ef2aSThomas Huth VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb) 614fcf5ef2aSThomas Huth VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh) 615fcf5ef2aSThomas Huth VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw) 616fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub) 617fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh) 618fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw) 619fcf5ef2aSThomas Huth #undef VARITHSAT_CASE 620fcf5ef2aSThomas Huth #undef VARITHSAT_DO 621fcf5ef2aSThomas Huth #undef VARITHSAT_SIGNED 622fcf5ef2aSThomas Huth #undef VARITHSAT_UNSIGNED 623fcf5ef2aSThomas Huth 624fcf5ef2aSThomas Huth #define VAVG_DO(name, element, etype) \ 625fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 626fcf5ef2aSThomas Huth { \ 627fcf5ef2aSThomas Huth int i; \ 628fcf5ef2aSThomas Huth \ 629fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 630fcf5ef2aSThomas Huth etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \ 631fcf5ef2aSThomas Huth r->element[i] = x >> 1; \ 632fcf5ef2aSThomas Huth } \ 633fcf5ef2aSThomas Huth } 634fcf5ef2aSThomas Huth 635fcf5ef2aSThomas Huth #define VAVG(type, signed_element, signed_type, unsigned_element, \ 636fcf5ef2aSThomas Huth unsigned_type) \ 637fcf5ef2aSThomas Huth VAVG_DO(avgs##type, signed_element, signed_type) \ 638fcf5ef2aSThomas Huth VAVG_DO(avgu##type, unsigned_element, unsigned_type) 639fcf5ef2aSThomas Huth VAVG(b, s8, int16_t, u8, uint16_t) 640fcf5ef2aSThomas Huth VAVG(h, s16, int32_t, u16, uint32_t) 641fcf5ef2aSThomas Huth VAVG(w, s32, int64_t, u32, uint64_t) 642fcf5ef2aSThomas Huth #undef VAVG_DO 643fcf5ef2aSThomas Huth #undef VAVG 644fcf5ef2aSThomas Huth 645fcf5ef2aSThomas Huth #define VABSDU_DO(name, element) \ 646fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 647fcf5ef2aSThomas Huth { \ 648fcf5ef2aSThomas Huth int i; \ 649fcf5ef2aSThomas Huth \ 650fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 651fcf5ef2aSThomas Huth r->element[i] = (a->element[i] > b->element[i]) ? \ 652fcf5ef2aSThomas Huth (a->element[i] - b->element[i]) : \ 653fcf5ef2aSThomas Huth (b->element[i] - a->element[i]); \ 654fcf5ef2aSThomas Huth } \ 655fcf5ef2aSThomas Huth } 656fcf5ef2aSThomas Huth 657b6cb41b2SDavid Gibson /* 658b6cb41b2SDavid Gibson * VABSDU - Vector absolute difference unsigned 659fcf5ef2aSThomas Huth * name - instruction mnemonic suffix (b: byte, h: halfword, w: word) 660fcf5ef2aSThomas Huth * element - element type to access from vector 661fcf5ef2aSThomas Huth */ 662fcf5ef2aSThomas Huth #define VABSDU(type, element) \ 663fcf5ef2aSThomas Huth VABSDU_DO(absdu##type, element) 664fcf5ef2aSThomas Huth VABSDU(b, u8) 665fcf5ef2aSThomas Huth VABSDU(h, u16) 666fcf5ef2aSThomas Huth VABSDU(w, u32) 667fcf5ef2aSThomas Huth #undef VABSDU_DO 668fcf5ef2aSThomas Huth #undef VABSDU 669fcf5ef2aSThomas Huth 670fcf5ef2aSThomas Huth #define VCF(suffix, cvt, element) \ 671fcf5ef2aSThomas Huth void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \ 672fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 673fcf5ef2aSThomas Huth { \ 674fcf5ef2aSThomas Huth int i; \ 675fcf5ef2aSThomas Huth \ 67605ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 677fcf5ef2aSThomas Huth float32 t = cvt(b->element[i], &env->vec_status); \ 67805ee3e8aSMark Cave-Ayland r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \ 679fcf5ef2aSThomas Huth } \ 680fcf5ef2aSThomas Huth } 681fcf5ef2aSThomas Huth VCF(ux, uint32_to_float32, u32) 682fcf5ef2aSThomas Huth VCF(sx, int32_to_float32, s32) 683fcf5ef2aSThomas Huth #undef VCF 684fcf5ef2aSThomas Huth 685fcf5ef2aSThomas Huth #define VCMP_DO(suffix, compare, element, record) \ 686fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 687fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 688fcf5ef2aSThomas Huth { \ 689fcf5ef2aSThomas Huth uint64_t ones = (uint64_t)-1; \ 690fcf5ef2aSThomas Huth uint64_t all = ones; \ 691fcf5ef2aSThomas Huth uint64_t none = 0; \ 692fcf5ef2aSThomas Huth int i; \ 693fcf5ef2aSThomas Huth \ 694fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 695fcf5ef2aSThomas Huth uint64_t result = (a->element[i] compare b->element[i] ? \ 696fcf5ef2aSThomas Huth ones : 0x0); \ 697fcf5ef2aSThomas Huth switch (sizeof(a->element[0])) { \ 698fcf5ef2aSThomas Huth case 8: \ 699fcf5ef2aSThomas Huth r->u64[i] = result; \ 700fcf5ef2aSThomas Huth break; \ 701fcf5ef2aSThomas Huth case 4: \ 702fcf5ef2aSThomas Huth r->u32[i] = result; \ 703fcf5ef2aSThomas Huth break; \ 704fcf5ef2aSThomas Huth case 2: \ 705fcf5ef2aSThomas Huth r->u16[i] = result; \ 706fcf5ef2aSThomas Huth break; \ 707fcf5ef2aSThomas Huth case 1: \ 708fcf5ef2aSThomas Huth r->u8[i] = result; \ 709fcf5ef2aSThomas Huth break; \ 710fcf5ef2aSThomas Huth } \ 711fcf5ef2aSThomas Huth all &= result; \ 712fcf5ef2aSThomas Huth none |= result; \ 713fcf5ef2aSThomas Huth } \ 714fcf5ef2aSThomas Huth if (record) { \ 715fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 716fcf5ef2aSThomas Huth } \ 717fcf5ef2aSThomas Huth } 718fcf5ef2aSThomas Huth #define VCMP(suffix, compare, element) \ 719fcf5ef2aSThomas Huth VCMP_DO(suffix, compare, element, 0) \ 720fcf5ef2aSThomas Huth VCMP_DO(suffix##_dot, compare, element, 1) 721fcf5ef2aSThomas Huth VCMP(equb, ==, u8) 722fcf5ef2aSThomas Huth VCMP(equh, ==, u16) 723fcf5ef2aSThomas Huth VCMP(equw, ==, u32) 724fcf5ef2aSThomas Huth VCMP(equd, ==, u64) 725fcf5ef2aSThomas Huth VCMP(gtub, >, u8) 726fcf5ef2aSThomas Huth VCMP(gtuh, >, u16) 727fcf5ef2aSThomas Huth VCMP(gtuw, >, u32) 728fcf5ef2aSThomas Huth VCMP(gtud, >, u64) 729fcf5ef2aSThomas Huth VCMP(gtsb, >, s8) 730fcf5ef2aSThomas Huth VCMP(gtsh, >, s16) 731fcf5ef2aSThomas Huth VCMP(gtsw, >, s32) 732fcf5ef2aSThomas Huth VCMP(gtsd, >, s64) 733fcf5ef2aSThomas Huth #undef VCMP_DO 734fcf5ef2aSThomas Huth #undef VCMP 735fcf5ef2aSThomas Huth 736fcf5ef2aSThomas Huth #define VCMPNE_DO(suffix, element, etype, cmpzero, record) \ 737fcf5ef2aSThomas Huth void helper_vcmpne##suffix(CPUPPCState *env, ppc_avr_t *r, \ 738fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 739fcf5ef2aSThomas Huth { \ 740fcf5ef2aSThomas Huth etype ones = (etype)-1; \ 741fcf5ef2aSThomas Huth etype all = ones; \ 742fcf5ef2aSThomas Huth etype result, none = 0; \ 743fcf5ef2aSThomas Huth int i; \ 744fcf5ef2aSThomas Huth \ 745fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 746fcf5ef2aSThomas Huth if (cmpzero) { \ 747fcf5ef2aSThomas Huth result = ((a->element[i] == 0) \ 748fcf5ef2aSThomas Huth || (b->element[i] == 0) \ 749fcf5ef2aSThomas Huth || (a->element[i] != b->element[i]) ? \ 750fcf5ef2aSThomas Huth ones : 0x0); \ 751fcf5ef2aSThomas Huth } else { \ 752fcf5ef2aSThomas Huth result = (a->element[i] != b->element[i]) ? ones : 0x0; \ 753fcf5ef2aSThomas Huth } \ 754fcf5ef2aSThomas Huth r->element[i] = result; \ 755fcf5ef2aSThomas Huth all &= result; \ 756fcf5ef2aSThomas Huth none |= result; \ 757fcf5ef2aSThomas Huth } \ 758fcf5ef2aSThomas Huth if (record) { \ 759fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 760fcf5ef2aSThomas Huth } \ 761fcf5ef2aSThomas Huth } 762fcf5ef2aSThomas Huth 763b6cb41b2SDavid Gibson /* 764b6cb41b2SDavid Gibson * VCMPNEZ - Vector compare not equal to zero 765fcf5ef2aSThomas Huth * suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word) 766fcf5ef2aSThomas Huth * element - element type to access from vector 767fcf5ef2aSThomas Huth */ 768fcf5ef2aSThomas Huth #define VCMPNE(suffix, element, etype, cmpzero) \ 769fcf5ef2aSThomas Huth VCMPNE_DO(suffix, element, etype, cmpzero, 0) \ 770fcf5ef2aSThomas Huth VCMPNE_DO(suffix##_dot, element, etype, cmpzero, 1) 771fcf5ef2aSThomas Huth VCMPNE(zb, u8, uint8_t, 1) 772fcf5ef2aSThomas Huth VCMPNE(zh, u16, uint16_t, 1) 773fcf5ef2aSThomas Huth VCMPNE(zw, u32, uint32_t, 1) 774fcf5ef2aSThomas Huth VCMPNE(b, u8, uint8_t, 0) 775fcf5ef2aSThomas Huth VCMPNE(h, u16, uint16_t, 0) 776fcf5ef2aSThomas Huth VCMPNE(w, u32, uint32_t, 0) 777fcf5ef2aSThomas Huth #undef VCMPNE_DO 778fcf5ef2aSThomas Huth #undef VCMPNE 779fcf5ef2aSThomas Huth 780fcf5ef2aSThomas Huth #define VCMPFP_DO(suffix, compare, order, record) \ 781fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 782fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 783fcf5ef2aSThomas Huth { \ 784fcf5ef2aSThomas Huth uint32_t ones = (uint32_t)-1; \ 785fcf5ef2aSThomas Huth uint32_t all = ones; \ 786fcf5ef2aSThomas Huth uint32_t none = 0; \ 787fcf5ef2aSThomas Huth int i; \ 788fcf5ef2aSThomas Huth \ 78905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 790fcf5ef2aSThomas Huth uint32_t result; \ 79105ee3e8aSMark Cave-Ayland int rel = float32_compare_quiet(a->f32[i], b->f32[i], \ 792fcf5ef2aSThomas Huth &env->vec_status); \ 793fcf5ef2aSThomas Huth if (rel == float_relation_unordered) { \ 794fcf5ef2aSThomas Huth result = 0; \ 795fcf5ef2aSThomas Huth } else if (rel compare order) { \ 796fcf5ef2aSThomas Huth result = ones; \ 797fcf5ef2aSThomas Huth } else { \ 798fcf5ef2aSThomas Huth result = 0; \ 799fcf5ef2aSThomas Huth } \ 800fcf5ef2aSThomas Huth r->u32[i] = result; \ 801fcf5ef2aSThomas Huth all &= result; \ 802fcf5ef2aSThomas Huth none |= result; \ 803fcf5ef2aSThomas Huth } \ 804fcf5ef2aSThomas Huth if (record) { \ 805fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 806fcf5ef2aSThomas Huth } \ 807fcf5ef2aSThomas Huth } 808fcf5ef2aSThomas Huth #define VCMPFP(suffix, compare, order) \ 809fcf5ef2aSThomas Huth VCMPFP_DO(suffix, compare, order, 0) \ 810fcf5ef2aSThomas Huth VCMPFP_DO(suffix##_dot, compare, order, 1) 811fcf5ef2aSThomas Huth VCMPFP(eqfp, ==, float_relation_equal) 812fcf5ef2aSThomas Huth VCMPFP(gefp, !=, float_relation_less) 813fcf5ef2aSThomas Huth VCMPFP(gtfp, ==, float_relation_greater) 814fcf5ef2aSThomas Huth #undef VCMPFP_DO 815fcf5ef2aSThomas Huth #undef VCMPFP 816fcf5ef2aSThomas Huth 817fcf5ef2aSThomas Huth static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r, 818fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b, int record) 819fcf5ef2aSThomas Huth { 820fcf5ef2aSThomas Huth int i; 821fcf5ef2aSThomas Huth int all_in = 0; 822fcf5ef2aSThomas Huth 82305ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 82405ee3e8aSMark Cave-Ayland int le_rel = float32_compare_quiet(a->f32[i], b->f32[i], 82505ee3e8aSMark Cave-Ayland &env->vec_status); 826fcf5ef2aSThomas Huth if (le_rel == float_relation_unordered) { 827fcf5ef2aSThomas Huth r->u32[i] = 0xc0000000; 828fcf5ef2aSThomas Huth all_in = 1; 829fcf5ef2aSThomas Huth } else { 83005ee3e8aSMark Cave-Ayland float32 bneg = float32_chs(b->f32[i]); 83105ee3e8aSMark Cave-Ayland int ge_rel = float32_compare_quiet(a->f32[i], bneg, 83205ee3e8aSMark Cave-Ayland &env->vec_status); 833fcf5ef2aSThomas Huth int le = le_rel != float_relation_greater; 834fcf5ef2aSThomas Huth int ge = ge_rel != float_relation_less; 835fcf5ef2aSThomas Huth 836fcf5ef2aSThomas Huth r->u32[i] = ((!le) << 31) | ((!ge) << 30); 837fcf5ef2aSThomas Huth all_in |= (!le | !ge); 838fcf5ef2aSThomas Huth } 839fcf5ef2aSThomas Huth } 840fcf5ef2aSThomas Huth if (record) { 841fcf5ef2aSThomas Huth env->crf[6] = (all_in == 0) << 1; 842fcf5ef2aSThomas Huth } 843fcf5ef2aSThomas Huth } 844fcf5ef2aSThomas Huth 845fcf5ef2aSThomas Huth void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 846fcf5ef2aSThomas Huth { 847fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 0); 848fcf5ef2aSThomas Huth } 849fcf5ef2aSThomas Huth 850fcf5ef2aSThomas Huth void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 851fcf5ef2aSThomas Huth ppc_avr_t *b) 852fcf5ef2aSThomas Huth { 853fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 1); 854fcf5ef2aSThomas Huth } 855fcf5ef2aSThomas Huth 856fcf5ef2aSThomas Huth #define VCT(suffix, satcvt, element) \ 857fcf5ef2aSThomas Huth void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \ 858fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 859fcf5ef2aSThomas Huth { \ 860fcf5ef2aSThomas Huth int i; \ 861fcf5ef2aSThomas Huth int sat = 0; \ 862fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 863fcf5ef2aSThomas Huth \ 864fcf5ef2aSThomas Huth set_float_rounding_mode(float_round_to_zero, &s); \ 86505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 86605ee3e8aSMark Cave-Ayland if (float32_is_any_nan(b->f32[i])) { \ 867fcf5ef2aSThomas Huth r->element[i] = 0; \ 868fcf5ef2aSThomas Huth } else { \ 86905ee3e8aSMark Cave-Ayland float64 t = float32_to_float64(b->f32[i], &s); \ 870fcf5ef2aSThomas Huth int64_t j; \ 871fcf5ef2aSThomas Huth \ 872fcf5ef2aSThomas Huth t = float64_scalbn(t, uim, &s); \ 873fcf5ef2aSThomas Huth j = float64_to_int64(t, &s); \ 874fcf5ef2aSThomas Huth r->element[i] = satcvt(j, &sat); \ 875fcf5ef2aSThomas Huth } \ 876fcf5ef2aSThomas Huth } \ 877fcf5ef2aSThomas Huth if (sat) { \ 8786175f5a0SRichard Henderson set_vscr_sat(env); \ 879fcf5ef2aSThomas Huth } \ 880fcf5ef2aSThomas Huth } 881fcf5ef2aSThomas Huth VCT(uxs, cvtsduw, u32) 882fcf5ef2aSThomas Huth VCT(sxs, cvtsdsw, s32) 883fcf5ef2aSThomas Huth #undef VCT 884fcf5ef2aSThomas Huth 885fcf5ef2aSThomas Huth target_ulong helper_vclzlsbb(ppc_avr_t *r) 886fcf5ef2aSThomas Huth { 887fcf5ef2aSThomas Huth target_ulong count = 0; 888fcf5ef2aSThomas Huth int i; 88960594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 89060594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 891fcf5ef2aSThomas Huth break; 892fcf5ef2aSThomas Huth } 893fcf5ef2aSThomas Huth count++; 894fcf5ef2aSThomas Huth } 895fcf5ef2aSThomas Huth return count; 896fcf5ef2aSThomas Huth } 897fcf5ef2aSThomas Huth 898fcf5ef2aSThomas Huth target_ulong helper_vctzlsbb(ppc_avr_t *r) 899fcf5ef2aSThomas Huth { 900fcf5ef2aSThomas Huth target_ulong count = 0; 901fcf5ef2aSThomas Huth int i; 902fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 90360594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 904fcf5ef2aSThomas Huth break; 905fcf5ef2aSThomas Huth } 906fcf5ef2aSThomas Huth count++; 907fcf5ef2aSThomas Huth } 908fcf5ef2aSThomas Huth return count; 909fcf5ef2aSThomas Huth } 910fcf5ef2aSThomas Huth 911fcf5ef2aSThomas Huth void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 912fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 913fcf5ef2aSThomas Huth { 914fcf5ef2aSThomas Huth int sat = 0; 915fcf5ef2aSThomas Huth int i; 916fcf5ef2aSThomas Huth 917fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 918fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 919fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 920fcf5ef2aSThomas Huth 921fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 922fcf5ef2aSThomas Huth } 923fcf5ef2aSThomas Huth 924fcf5ef2aSThomas Huth if (sat) { 9256175f5a0SRichard Henderson set_vscr_sat(env); 926fcf5ef2aSThomas Huth } 927fcf5ef2aSThomas Huth } 928fcf5ef2aSThomas Huth 929fcf5ef2aSThomas Huth void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 930fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 931fcf5ef2aSThomas Huth { 932fcf5ef2aSThomas Huth int sat = 0; 933fcf5ef2aSThomas Huth int i; 934fcf5ef2aSThomas Huth 935fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 936fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i] + 0x00004000; 937fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 938fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 939fcf5ef2aSThomas Huth } 940fcf5ef2aSThomas Huth 941fcf5ef2aSThomas Huth if (sat) { 9426175f5a0SRichard Henderson set_vscr_sat(env); 943fcf5ef2aSThomas Huth } 944fcf5ef2aSThomas Huth } 945fcf5ef2aSThomas Huth 946fcf5ef2aSThomas Huth void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 947fcf5ef2aSThomas Huth { 948fcf5ef2aSThomas Huth int i; 949fcf5ef2aSThomas Huth 950fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 951fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 952fcf5ef2aSThomas Huth r->s16[i] = (int16_t) (prod + c->s16[i]); 953fcf5ef2aSThomas Huth } 954fcf5ef2aSThomas Huth } 955fcf5ef2aSThomas Huth 956d81c2040SMark Cave-Ayland #define VMRG_DO(name, element, access, ofs) \ 957fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 958fcf5ef2aSThomas Huth { \ 959fcf5ef2aSThomas Huth ppc_avr_t result; \ 960d81c2040SMark Cave-Ayland int i, half = ARRAY_SIZE(r->element) / 2; \ 961fcf5ef2aSThomas Huth \ 962d81c2040SMark Cave-Ayland for (i = 0; i < half; i++) { \ 963d81c2040SMark Cave-Ayland result.access(i * 2 + 0) = a->access(i + ofs); \ 964d81c2040SMark Cave-Ayland result.access(i * 2 + 1) = b->access(i + ofs); \ 965fcf5ef2aSThomas Huth } \ 966fcf5ef2aSThomas Huth *r = result; \ 967fcf5ef2aSThomas Huth } 968d81c2040SMark Cave-Ayland 969d81c2040SMark Cave-Ayland #define VMRG(suffix, element, access) \ 970d81c2040SMark Cave-Ayland VMRG_DO(mrgl##suffix, element, access, half) \ 971d81c2040SMark Cave-Ayland VMRG_DO(mrgh##suffix, element, access, 0) 972d81c2040SMark Cave-Ayland VMRG(b, u8, VsrB) 973d81c2040SMark Cave-Ayland VMRG(h, u16, VsrH) 974d81c2040SMark Cave-Ayland VMRG(w, u32, VsrW) 975fcf5ef2aSThomas Huth #undef VMRG_DO 976fcf5ef2aSThomas Huth #undef VMRG 977fcf5ef2aSThomas Huth 978fcf5ef2aSThomas Huth void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 979fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 980fcf5ef2aSThomas Huth { 981fcf5ef2aSThomas Huth int32_t prod[16]; 982fcf5ef2aSThomas Huth int i; 983fcf5ef2aSThomas Huth 984fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s8); i++) { 985fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s8[i] * b->u8[i]; 986fcf5ef2aSThomas Huth } 987fcf5ef2aSThomas Huth 988fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 989fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] + 990fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 991fcf5ef2aSThomas Huth } 992fcf5ef2aSThomas Huth } 993fcf5ef2aSThomas Huth 994fcf5ef2aSThomas Huth void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 995fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 996fcf5ef2aSThomas Huth { 997fcf5ef2aSThomas Huth int32_t prod[8]; 998fcf5ef2aSThomas Huth int i; 999fcf5ef2aSThomas Huth 1000fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1001fcf5ef2aSThomas Huth prod[i] = a->s16[i] * b->s16[i]; 1002fcf5ef2aSThomas Huth } 1003fcf5ef2aSThomas Huth 1004fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1005fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1006fcf5ef2aSThomas Huth } 1007fcf5ef2aSThomas Huth } 1008fcf5ef2aSThomas Huth 1009fcf5ef2aSThomas Huth void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1010fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1011fcf5ef2aSThomas Huth { 1012fcf5ef2aSThomas Huth int32_t prod[8]; 1013fcf5ef2aSThomas Huth int i; 1014fcf5ef2aSThomas Huth int sat = 0; 1015fcf5ef2aSThomas Huth 1016fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1017fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s16[i] * b->s16[i]; 1018fcf5ef2aSThomas Huth } 1019fcf5ef2aSThomas Huth 1020fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1021fcf5ef2aSThomas Huth int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1022fcf5ef2aSThomas Huth 1023fcf5ef2aSThomas Huth r->u32[i] = cvtsdsw(t, &sat); 1024fcf5ef2aSThomas Huth } 1025fcf5ef2aSThomas Huth 1026fcf5ef2aSThomas Huth if (sat) { 10276175f5a0SRichard Henderson set_vscr_sat(env); 1028fcf5ef2aSThomas Huth } 1029fcf5ef2aSThomas Huth } 1030fcf5ef2aSThomas Huth 1031fcf5ef2aSThomas Huth void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1032fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1033fcf5ef2aSThomas Huth { 1034fcf5ef2aSThomas Huth uint16_t prod[16]; 1035fcf5ef2aSThomas Huth int i; 1036fcf5ef2aSThomas Huth 1037fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1038fcf5ef2aSThomas Huth prod[i] = a->u8[i] * b->u8[i]; 1039fcf5ef2aSThomas Huth } 1040fcf5ef2aSThomas Huth 1041fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1042fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] + 1043fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1044fcf5ef2aSThomas Huth } 1045fcf5ef2aSThomas Huth } 1046fcf5ef2aSThomas Huth 1047fcf5ef2aSThomas Huth void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1048fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1049fcf5ef2aSThomas Huth { 1050fcf5ef2aSThomas Huth uint32_t prod[8]; 1051fcf5ef2aSThomas Huth int i; 1052fcf5ef2aSThomas Huth 1053fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1054fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1055fcf5ef2aSThomas Huth } 1056fcf5ef2aSThomas Huth 1057fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1058fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1059fcf5ef2aSThomas Huth } 1060fcf5ef2aSThomas Huth } 1061fcf5ef2aSThomas Huth 1062fcf5ef2aSThomas Huth void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1063fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1064fcf5ef2aSThomas Huth { 1065fcf5ef2aSThomas Huth uint32_t prod[8]; 1066fcf5ef2aSThomas Huth int i; 1067fcf5ef2aSThomas Huth int sat = 0; 1068fcf5ef2aSThomas Huth 1069fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1070fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1071fcf5ef2aSThomas Huth } 1072fcf5ef2aSThomas Huth 1073fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1074fcf5ef2aSThomas Huth uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1075fcf5ef2aSThomas Huth 1076fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1077fcf5ef2aSThomas Huth } 1078fcf5ef2aSThomas Huth 1079fcf5ef2aSThomas Huth if (sat) { 10806175f5a0SRichard Henderson set_vscr_sat(env); 1081fcf5ef2aSThomas Huth } 1082fcf5ef2aSThomas Huth } 1083fcf5ef2aSThomas Huth 10844fbc89edSMark Cave-Ayland #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast) \ 1085fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1086fcf5ef2aSThomas Huth { \ 1087fcf5ef2aSThomas Huth int i; \ 1088fcf5ef2aSThomas Huth \ 10894fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 10904fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i) * \ 10914fbc89edSMark Cave-Ayland (cast)b->mul_access(i); \ 1092fcf5ef2aSThomas Huth } \ 1093fcf5ef2aSThomas Huth } 10944fbc89edSMark Cave-Ayland 10954fbc89edSMark Cave-Ayland #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast) \ 10964fbc89edSMark Cave-Ayland void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 10974fbc89edSMark Cave-Ayland { \ 10984fbc89edSMark Cave-Ayland int i; \ 10994fbc89edSMark Cave-Ayland \ 11004fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 11014fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) * \ 11024fbc89edSMark Cave-Ayland (cast)b->mul_access(i + 1); \ 11034fbc89edSMark Cave-Ayland } \ 11044fbc89edSMark Cave-Ayland } 11054fbc89edSMark Cave-Ayland 11064fbc89edSMark Cave-Ayland #define VMUL(suffix, mul_element, mul_access, prod_access, cast) \ 11074fbc89edSMark Cave-Ayland VMUL_DO_EVN(mule##suffix, mul_element, mul_access, prod_access, cast) \ 11084fbc89edSMark Cave-Ayland VMUL_DO_ODD(mulo##suffix, mul_element, mul_access, prod_access, cast) 11094fbc89edSMark Cave-Ayland VMUL(sb, s8, VsrSB, VsrSH, int16_t) 11104fbc89edSMark Cave-Ayland VMUL(sh, s16, VsrSH, VsrSW, int32_t) 11114fbc89edSMark Cave-Ayland VMUL(sw, s32, VsrSW, VsrSD, int64_t) 11124fbc89edSMark Cave-Ayland VMUL(ub, u8, VsrB, VsrH, uint16_t) 11134fbc89edSMark Cave-Ayland VMUL(uh, u16, VsrH, VsrW, uint32_t) 11144fbc89edSMark Cave-Ayland VMUL(uw, u32, VsrW, VsrD, uint64_t) 11154fbc89edSMark Cave-Ayland #undef VMUL_DO_EVN 11164fbc89edSMark Cave-Ayland #undef VMUL_DO_ODD 1117fcf5ef2aSThomas Huth #undef VMUL 1118fcf5ef2aSThomas Huth 1119fcf5ef2aSThomas Huth void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1120fcf5ef2aSThomas Huth ppc_avr_t *c) 1121fcf5ef2aSThomas Huth { 1122fcf5ef2aSThomas Huth ppc_avr_t result; 1123fcf5ef2aSThomas Huth int i; 1124fcf5ef2aSThomas Huth 112560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 112660594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1127fcf5ef2aSThomas Huth int index = s & 0xf; 1128fcf5ef2aSThomas Huth 1129fcf5ef2aSThomas Huth if (s & 0x10) { 113060594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1131fcf5ef2aSThomas Huth } else { 113260594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1133fcf5ef2aSThomas Huth } 1134fcf5ef2aSThomas Huth } 1135fcf5ef2aSThomas Huth *r = result; 1136fcf5ef2aSThomas Huth } 1137fcf5ef2aSThomas Huth 1138fcf5ef2aSThomas Huth void helper_vpermr(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1139fcf5ef2aSThomas Huth ppc_avr_t *c) 1140fcf5ef2aSThomas Huth { 1141fcf5ef2aSThomas Huth ppc_avr_t result; 1142fcf5ef2aSThomas Huth int i; 1143fcf5ef2aSThomas Huth 114460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 114560594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1146fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1147fcf5ef2aSThomas Huth 1148fcf5ef2aSThomas Huth if (s & 0x10) { 114960594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1150fcf5ef2aSThomas Huth } else { 115160594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1152fcf5ef2aSThomas Huth } 1153fcf5ef2aSThomas Huth } 1154fcf5ef2aSThomas Huth *r = result; 1155fcf5ef2aSThomas Huth } 1156fcf5ef2aSThomas Huth 1157fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1158fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)]) 1159fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (i) 1160fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) != 0) 1161fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1)) 1162fcf5ef2aSThomas Huth #else 1163fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)]) 1164fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (1 - i) 1165fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) == 0) 1166fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) \ 1167fcf5ef2aSThomas Huth (extract64((avr)->u64[1 - i], 63 - index, 1)) 1168fcf5ef2aSThomas Huth #endif 1169fcf5ef2aSThomas Huth 1170fcf5ef2aSThomas Huth void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1171fcf5ef2aSThomas Huth { 1172fcf5ef2aSThomas Huth int i, j; 1173fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 1174fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1175fcf5ef2aSThomas Huth for (j = 0; j < 8; j++) { 1176fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, (i * 8) + j); 1177fcf5ef2aSThomas Huth if (index < 64 && EXTRACT_BIT(a, i, index)) { 1178fcf5ef2aSThomas Huth result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j); 1179fcf5ef2aSThomas Huth } 1180fcf5ef2aSThomas Huth } 1181fcf5ef2aSThomas Huth } 1182fcf5ef2aSThomas Huth *r = result; 1183fcf5ef2aSThomas Huth } 1184fcf5ef2aSThomas Huth 1185fcf5ef2aSThomas Huth void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1186fcf5ef2aSThomas Huth { 1187fcf5ef2aSThomas Huth int i; 1188fcf5ef2aSThomas Huth uint64_t perm = 0; 1189fcf5ef2aSThomas Huth 1190fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1191fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, i); 1192fcf5ef2aSThomas Huth 1193fcf5ef2aSThomas Huth if (index < 128) { 1194fcf5ef2aSThomas Huth uint64_t mask = (1ull << (63 - (index & 0x3F))); 1195fcf5ef2aSThomas Huth if (a->u64[VBPERMQ_DW(index)] & mask) { 1196fcf5ef2aSThomas Huth perm |= (0x8000 >> i); 1197fcf5ef2aSThomas Huth } 1198fcf5ef2aSThomas Huth } 1199fcf5ef2aSThomas Huth } 1200fcf5ef2aSThomas Huth 12013c385a93SMark Cave-Ayland r->VsrD(0) = perm; 12023c385a93SMark Cave-Ayland r->VsrD(1) = 0; 1203fcf5ef2aSThomas Huth } 1204fcf5ef2aSThomas Huth 1205fcf5ef2aSThomas Huth #undef VBPERMQ_INDEX 1206fcf5ef2aSThomas Huth #undef VBPERMQ_DW 1207fcf5ef2aSThomas Huth 1208fcf5ef2aSThomas Huth static const uint64_t VGBBD_MASKS[256] = { 1209fcf5ef2aSThomas Huth 0x0000000000000000ull, /* 00 */ 1210fcf5ef2aSThomas Huth 0x0000000000000080ull, /* 01 */ 1211fcf5ef2aSThomas Huth 0x0000000000008000ull, /* 02 */ 1212fcf5ef2aSThomas Huth 0x0000000000008080ull, /* 03 */ 1213fcf5ef2aSThomas Huth 0x0000000000800000ull, /* 04 */ 1214fcf5ef2aSThomas Huth 0x0000000000800080ull, /* 05 */ 1215fcf5ef2aSThomas Huth 0x0000000000808000ull, /* 06 */ 1216fcf5ef2aSThomas Huth 0x0000000000808080ull, /* 07 */ 1217fcf5ef2aSThomas Huth 0x0000000080000000ull, /* 08 */ 1218fcf5ef2aSThomas Huth 0x0000000080000080ull, /* 09 */ 1219fcf5ef2aSThomas Huth 0x0000000080008000ull, /* 0A */ 1220fcf5ef2aSThomas Huth 0x0000000080008080ull, /* 0B */ 1221fcf5ef2aSThomas Huth 0x0000000080800000ull, /* 0C */ 1222fcf5ef2aSThomas Huth 0x0000000080800080ull, /* 0D */ 1223fcf5ef2aSThomas Huth 0x0000000080808000ull, /* 0E */ 1224fcf5ef2aSThomas Huth 0x0000000080808080ull, /* 0F */ 1225fcf5ef2aSThomas Huth 0x0000008000000000ull, /* 10 */ 1226fcf5ef2aSThomas Huth 0x0000008000000080ull, /* 11 */ 1227fcf5ef2aSThomas Huth 0x0000008000008000ull, /* 12 */ 1228fcf5ef2aSThomas Huth 0x0000008000008080ull, /* 13 */ 1229fcf5ef2aSThomas Huth 0x0000008000800000ull, /* 14 */ 1230fcf5ef2aSThomas Huth 0x0000008000800080ull, /* 15 */ 1231fcf5ef2aSThomas Huth 0x0000008000808000ull, /* 16 */ 1232fcf5ef2aSThomas Huth 0x0000008000808080ull, /* 17 */ 1233fcf5ef2aSThomas Huth 0x0000008080000000ull, /* 18 */ 1234fcf5ef2aSThomas Huth 0x0000008080000080ull, /* 19 */ 1235fcf5ef2aSThomas Huth 0x0000008080008000ull, /* 1A */ 1236fcf5ef2aSThomas Huth 0x0000008080008080ull, /* 1B */ 1237fcf5ef2aSThomas Huth 0x0000008080800000ull, /* 1C */ 1238fcf5ef2aSThomas Huth 0x0000008080800080ull, /* 1D */ 1239fcf5ef2aSThomas Huth 0x0000008080808000ull, /* 1E */ 1240fcf5ef2aSThomas Huth 0x0000008080808080ull, /* 1F */ 1241fcf5ef2aSThomas Huth 0x0000800000000000ull, /* 20 */ 1242fcf5ef2aSThomas Huth 0x0000800000000080ull, /* 21 */ 1243fcf5ef2aSThomas Huth 0x0000800000008000ull, /* 22 */ 1244fcf5ef2aSThomas Huth 0x0000800000008080ull, /* 23 */ 1245fcf5ef2aSThomas Huth 0x0000800000800000ull, /* 24 */ 1246fcf5ef2aSThomas Huth 0x0000800000800080ull, /* 25 */ 1247fcf5ef2aSThomas Huth 0x0000800000808000ull, /* 26 */ 1248fcf5ef2aSThomas Huth 0x0000800000808080ull, /* 27 */ 1249fcf5ef2aSThomas Huth 0x0000800080000000ull, /* 28 */ 1250fcf5ef2aSThomas Huth 0x0000800080000080ull, /* 29 */ 1251fcf5ef2aSThomas Huth 0x0000800080008000ull, /* 2A */ 1252fcf5ef2aSThomas Huth 0x0000800080008080ull, /* 2B */ 1253fcf5ef2aSThomas Huth 0x0000800080800000ull, /* 2C */ 1254fcf5ef2aSThomas Huth 0x0000800080800080ull, /* 2D */ 1255fcf5ef2aSThomas Huth 0x0000800080808000ull, /* 2E */ 1256fcf5ef2aSThomas Huth 0x0000800080808080ull, /* 2F */ 1257fcf5ef2aSThomas Huth 0x0000808000000000ull, /* 30 */ 1258fcf5ef2aSThomas Huth 0x0000808000000080ull, /* 31 */ 1259fcf5ef2aSThomas Huth 0x0000808000008000ull, /* 32 */ 1260fcf5ef2aSThomas Huth 0x0000808000008080ull, /* 33 */ 1261fcf5ef2aSThomas Huth 0x0000808000800000ull, /* 34 */ 1262fcf5ef2aSThomas Huth 0x0000808000800080ull, /* 35 */ 1263fcf5ef2aSThomas Huth 0x0000808000808000ull, /* 36 */ 1264fcf5ef2aSThomas Huth 0x0000808000808080ull, /* 37 */ 1265fcf5ef2aSThomas Huth 0x0000808080000000ull, /* 38 */ 1266fcf5ef2aSThomas Huth 0x0000808080000080ull, /* 39 */ 1267fcf5ef2aSThomas Huth 0x0000808080008000ull, /* 3A */ 1268fcf5ef2aSThomas Huth 0x0000808080008080ull, /* 3B */ 1269fcf5ef2aSThomas Huth 0x0000808080800000ull, /* 3C */ 1270fcf5ef2aSThomas Huth 0x0000808080800080ull, /* 3D */ 1271fcf5ef2aSThomas Huth 0x0000808080808000ull, /* 3E */ 1272fcf5ef2aSThomas Huth 0x0000808080808080ull, /* 3F */ 1273fcf5ef2aSThomas Huth 0x0080000000000000ull, /* 40 */ 1274fcf5ef2aSThomas Huth 0x0080000000000080ull, /* 41 */ 1275fcf5ef2aSThomas Huth 0x0080000000008000ull, /* 42 */ 1276fcf5ef2aSThomas Huth 0x0080000000008080ull, /* 43 */ 1277fcf5ef2aSThomas Huth 0x0080000000800000ull, /* 44 */ 1278fcf5ef2aSThomas Huth 0x0080000000800080ull, /* 45 */ 1279fcf5ef2aSThomas Huth 0x0080000000808000ull, /* 46 */ 1280fcf5ef2aSThomas Huth 0x0080000000808080ull, /* 47 */ 1281fcf5ef2aSThomas Huth 0x0080000080000000ull, /* 48 */ 1282fcf5ef2aSThomas Huth 0x0080000080000080ull, /* 49 */ 1283fcf5ef2aSThomas Huth 0x0080000080008000ull, /* 4A */ 1284fcf5ef2aSThomas Huth 0x0080000080008080ull, /* 4B */ 1285fcf5ef2aSThomas Huth 0x0080000080800000ull, /* 4C */ 1286fcf5ef2aSThomas Huth 0x0080000080800080ull, /* 4D */ 1287fcf5ef2aSThomas Huth 0x0080000080808000ull, /* 4E */ 1288fcf5ef2aSThomas Huth 0x0080000080808080ull, /* 4F */ 1289fcf5ef2aSThomas Huth 0x0080008000000000ull, /* 50 */ 1290fcf5ef2aSThomas Huth 0x0080008000000080ull, /* 51 */ 1291fcf5ef2aSThomas Huth 0x0080008000008000ull, /* 52 */ 1292fcf5ef2aSThomas Huth 0x0080008000008080ull, /* 53 */ 1293fcf5ef2aSThomas Huth 0x0080008000800000ull, /* 54 */ 1294fcf5ef2aSThomas Huth 0x0080008000800080ull, /* 55 */ 1295fcf5ef2aSThomas Huth 0x0080008000808000ull, /* 56 */ 1296fcf5ef2aSThomas Huth 0x0080008000808080ull, /* 57 */ 1297fcf5ef2aSThomas Huth 0x0080008080000000ull, /* 58 */ 1298fcf5ef2aSThomas Huth 0x0080008080000080ull, /* 59 */ 1299fcf5ef2aSThomas Huth 0x0080008080008000ull, /* 5A */ 1300fcf5ef2aSThomas Huth 0x0080008080008080ull, /* 5B */ 1301fcf5ef2aSThomas Huth 0x0080008080800000ull, /* 5C */ 1302fcf5ef2aSThomas Huth 0x0080008080800080ull, /* 5D */ 1303fcf5ef2aSThomas Huth 0x0080008080808000ull, /* 5E */ 1304fcf5ef2aSThomas Huth 0x0080008080808080ull, /* 5F */ 1305fcf5ef2aSThomas Huth 0x0080800000000000ull, /* 60 */ 1306fcf5ef2aSThomas Huth 0x0080800000000080ull, /* 61 */ 1307fcf5ef2aSThomas Huth 0x0080800000008000ull, /* 62 */ 1308fcf5ef2aSThomas Huth 0x0080800000008080ull, /* 63 */ 1309fcf5ef2aSThomas Huth 0x0080800000800000ull, /* 64 */ 1310fcf5ef2aSThomas Huth 0x0080800000800080ull, /* 65 */ 1311fcf5ef2aSThomas Huth 0x0080800000808000ull, /* 66 */ 1312fcf5ef2aSThomas Huth 0x0080800000808080ull, /* 67 */ 1313fcf5ef2aSThomas Huth 0x0080800080000000ull, /* 68 */ 1314fcf5ef2aSThomas Huth 0x0080800080000080ull, /* 69 */ 1315fcf5ef2aSThomas Huth 0x0080800080008000ull, /* 6A */ 1316fcf5ef2aSThomas Huth 0x0080800080008080ull, /* 6B */ 1317fcf5ef2aSThomas Huth 0x0080800080800000ull, /* 6C */ 1318fcf5ef2aSThomas Huth 0x0080800080800080ull, /* 6D */ 1319fcf5ef2aSThomas Huth 0x0080800080808000ull, /* 6E */ 1320fcf5ef2aSThomas Huth 0x0080800080808080ull, /* 6F */ 1321fcf5ef2aSThomas Huth 0x0080808000000000ull, /* 70 */ 1322fcf5ef2aSThomas Huth 0x0080808000000080ull, /* 71 */ 1323fcf5ef2aSThomas Huth 0x0080808000008000ull, /* 72 */ 1324fcf5ef2aSThomas Huth 0x0080808000008080ull, /* 73 */ 1325fcf5ef2aSThomas Huth 0x0080808000800000ull, /* 74 */ 1326fcf5ef2aSThomas Huth 0x0080808000800080ull, /* 75 */ 1327fcf5ef2aSThomas Huth 0x0080808000808000ull, /* 76 */ 1328fcf5ef2aSThomas Huth 0x0080808000808080ull, /* 77 */ 1329fcf5ef2aSThomas Huth 0x0080808080000000ull, /* 78 */ 1330fcf5ef2aSThomas Huth 0x0080808080000080ull, /* 79 */ 1331fcf5ef2aSThomas Huth 0x0080808080008000ull, /* 7A */ 1332fcf5ef2aSThomas Huth 0x0080808080008080ull, /* 7B */ 1333fcf5ef2aSThomas Huth 0x0080808080800000ull, /* 7C */ 1334fcf5ef2aSThomas Huth 0x0080808080800080ull, /* 7D */ 1335fcf5ef2aSThomas Huth 0x0080808080808000ull, /* 7E */ 1336fcf5ef2aSThomas Huth 0x0080808080808080ull, /* 7F */ 1337fcf5ef2aSThomas Huth 0x8000000000000000ull, /* 80 */ 1338fcf5ef2aSThomas Huth 0x8000000000000080ull, /* 81 */ 1339fcf5ef2aSThomas Huth 0x8000000000008000ull, /* 82 */ 1340fcf5ef2aSThomas Huth 0x8000000000008080ull, /* 83 */ 1341fcf5ef2aSThomas Huth 0x8000000000800000ull, /* 84 */ 1342fcf5ef2aSThomas Huth 0x8000000000800080ull, /* 85 */ 1343fcf5ef2aSThomas Huth 0x8000000000808000ull, /* 86 */ 1344fcf5ef2aSThomas Huth 0x8000000000808080ull, /* 87 */ 1345fcf5ef2aSThomas Huth 0x8000000080000000ull, /* 88 */ 1346fcf5ef2aSThomas Huth 0x8000000080000080ull, /* 89 */ 1347fcf5ef2aSThomas Huth 0x8000000080008000ull, /* 8A */ 1348fcf5ef2aSThomas Huth 0x8000000080008080ull, /* 8B */ 1349fcf5ef2aSThomas Huth 0x8000000080800000ull, /* 8C */ 1350fcf5ef2aSThomas Huth 0x8000000080800080ull, /* 8D */ 1351fcf5ef2aSThomas Huth 0x8000000080808000ull, /* 8E */ 1352fcf5ef2aSThomas Huth 0x8000000080808080ull, /* 8F */ 1353fcf5ef2aSThomas Huth 0x8000008000000000ull, /* 90 */ 1354fcf5ef2aSThomas Huth 0x8000008000000080ull, /* 91 */ 1355fcf5ef2aSThomas Huth 0x8000008000008000ull, /* 92 */ 1356fcf5ef2aSThomas Huth 0x8000008000008080ull, /* 93 */ 1357fcf5ef2aSThomas Huth 0x8000008000800000ull, /* 94 */ 1358fcf5ef2aSThomas Huth 0x8000008000800080ull, /* 95 */ 1359fcf5ef2aSThomas Huth 0x8000008000808000ull, /* 96 */ 1360fcf5ef2aSThomas Huth 0x8000008000808080ull, /* 97 */ 1361fcf5ef2aSThomas Huth 0x8000008080000000ull, /* 98 */ 1362fcf5ef2aSThomas Huth 0x8000008080000080ull, /* 99 */ 1363fcf5ef2aSThomas Huth 0x8000008080008000ull, /* 9A */ 1364fcf5ef2aSThomas Huth 0x8000008080008080ull, /* 9B */ 1365fcf5ef2aSThomas Huth 0x8000008080800000ull, /* 9C */ 1366fcf5ef2aSThomas Huth 0x8000008080800080ull, /* 9D */ 1367fcf5ef2aSThomas Huth 0x8000008080808000ull, /* 9E */ 1368fcf5ef2aSThomas Huth 0x8000008080808080ull, /* 9F */ 1369fcf5ef2aSThomas Huth 0x8000800000000000ull, /* A0 */ 1370fcf5ef2aSThomas Huth 0x8000800000000080ull, /* A1 */ 1371fcf5ef2aSThomas Huth 0x8000800000008000ull, /* A2 */ 1372fcf5ef2aSThomas Huth 0x8000800000008080ull, /* A3 */ 1373fcf5ef2aSThomas Huth 0x8000800000800000ull, /* A4 */ 1374fcf5ef2aSThomas Huth 0x8000800000800080ull, /* A5 */ 1375fcf5ef2aSThomas Huth 0x8000800000808000ull, /* A6 */ 1376fcf5ef2aSThomas Huth 0x8000800000808080ull, /* A7 */ 1377fcf5ef2aSThomas Huth 0x8000800080000000ull, /* A8 */ 1378fcf5ef2aSThomas Huth 0x8000800080000080ull, /* A9 */ 1379fcf5ef2aSThomas Huth 0x8000800080008000ull, /* AA */ 1380fcf5ef2aSThomas Huth 0x8000800080008080ull, /* AB */ 1381fcf5ef2aSThomas Huth 0x8000800080800000ull, /* AC */ 1382fcf5ef2aSThomas Huth 0x8000800080800080ull, /* AD */ 1383fcf5ef2aSThomas Huth 0x8000800080808000ull, /* AE */ 1384fcf5ef2aSThomas Huth 0x8000800080808080ull, /* AF */ 1385fcf5ef2aSThomas Huth 0x8000808000000000ull, /* B0 */ 1386fcf5ef2aSThomas Huth 0x8000808000000080ull, /* B1 */ 1387fcf5ef2aSThomas Huth 0x8000808000008000ull, /* B2 */ 1388fcf5ef2aSThomas Huth 0x8000808000008080ull, /* B3 */ 1389fcf5ef2aSThomas Huth 0x8000808000800000ull, /* B4 */ 1390fcf5ef2aSThomas Huth 0x8000808000800080ull, /* B5 */ 1391fcf5ef2aSThomas Huth 0x8000808000808000ull, /* B6 */ 1392fcf5ef2aSThomas Huth 0x8000808000808080ull, /* B7 */ 1393fcf5ef2aSThomas Huth 0x8000808080000000ull, /* B8 */ 1394fcf5ef2aSThomas Huth 0x8000808080000080ull, /* B9 */ 1395fcf5ef2aSThomas Huth 0x8000808080008000ull, /* BA */ 1396fcf5ef2aSThomas Huth 0x8000808080008080ull, /* BB */ 1397fcf5ef2aSThomas Huth 0x8000808080800000ull, /* BC */ 1398fcf5ef2aSThomas Huth 0x8000808080800080ull, /* BD */ 1399fcf5ef2aSThomas Huth 0x8000808080808000ull, /* BE */ 1400fcf5ef2aSThomas Huth 0x8000808080808080ull, /* BF */ 1401fcf5ef2aSThomas Huth 0x8080000000000000ull, /* C0 */ 1402fcf5ef2aSThomas Huth 0x8080000000000080ull, /* C1 */ 1403fcf5ef2aSThomas Huth 0x8080000000008000ull, /* C2 */ 1404fcf5ef2aSThomas Huth 0x8080000000008080ull, /* C3 */ 1405fcf5ef2aSThomas Huth 0x8080000000800000ull, /* C4 */ 1406fcf5ef2aSThomas Huth 0x8080000000800080ull, /* C5 */ 1407fcf5ef2aSThomas Huth 0x8080000000808000ull, /* C6 */ 1408fcf5ef2aSThomas Huth 0x8080000000808080ull, /* C7 */ 1409fcf5ef2aSThomas Huth 0x8080000080000000ull, /* C8 */ 1410fcf5ef2aSThomas Huth 0x8080000080000080ull, /* C9 */ 1411fcf5ef2aSThomas Huth 0x8080000080008000ull, /* CA */ 1412fcf5ef2aSThomas Huth 0x8080000080008080ull, /* CB */ 1413fcf5ef2aSThomas Huth 0x8080000080800000ull, /* CC */ 1414fcf5ef2aSThomas Huth 0x8080000080800080ull, /* CD */ 1415fcf5ef2aSThomas Huth 0x8080000080808000ull, /* CE */ 1416fcf5ef2aSThomas Huth 0x8080000080808080ull, /* CF */ 1417fcf5ef2aSThomas Huth 0x8080008000000000ull, /* D0 */ 1418fcf5ef2aSThomas Huth 0x8080008000000080ull, /* D1 */ 1419fcf5ef2aSThomas Huth 0x8080008000008000ull, /* D2 */ 1420fcf5ef2aSThomas Huth 0x8080008000008080ull, /* D3 */ 1421fcf5ef2aSThomas Huth 0x8080008000800000ull, /* D4 */ 1422fcf5ef2aSThomas Huth 0x8080008000800080ull, /* D5 */ 1423fcf5ef2aSThomas Huth 0x8080008000808000ull, /* D6 */ 1424fcf5ef2aSThomas Huth 0x8080008000808080ull, /* D7 */ 1425fcf5ef2aSThomas Huth 0x8080008080000000ull, /* D8 */ 1426fcf5ef2aSThomas Huth 0x8080008080000080ull, /* D9 */ 1427fcf5ef2aSThomas Huth 0x8080008080008000ull, /* DA */ 1428fcf5ef2aSThomas Huth 0x8080008080008080ull, /* DB */ 1429fcf5ef2aSThomas Huth 0x8080008080800000ull, /* DC */ 1430fcf5ef2aSThomas Huth 0x8080008080800080ull, /* DD */ 1431fcf5ef2aSThomas Huth 0x8080008080808000ull, /* DE */ 1432fcf5ef2aSThomas Huth 0x8080008080808080ull, /* DF */ 1433fcf5ef2aSThomas Huth 0x8080800000000000ull, /* E0 */ 1434fcf5ef2aSThomas Huth 0x8080800000000080ull, /* E1 */ 1435fcf5ef2aSThomas Huth 0x8080800000008000ull, /* E2 */ 1436fcf5ef2aSThomas Huth 0x8080800000008080ull, /* E3 */ 1437fcf5ef2aSThomas Huth 0x8080800000800000ull, /* E4 */ 1438fcf5ef2aSThomas Huth 0x8080800000800080ull, /* E5 */ 1439fcf5ef2aSThomas Huth 0x8080800000808000ull, /* E6 */ 1440fcf5ef2aSThomas Huth 0x8080800000808080ull, /* E7 */ 1441fcf5ef2aSThomas Huth 0x8080800080000000ull, /* E8 */ 1442fcf5ef2aSThomas Huth 0x8080800080000080ull, /* E9 */ 1443fcf5ef2aSThomas Huth 0x8080800080008000ull, /* EA */ 1444fcf5ef2aSThomas Huth 0x8080800080008080ull, /* EB */ 1445fcf5ef2aSThomas Huth 0x8080800080800000ull, /* EC */ 1446fcf5ef2aSThomas Huth 0x8080800080800080ull, /* ED */ 1447fcf5ef2aSThomas Huth 0x8080800080808000ull, /* EE */ 1448fcf5ef2aSThomas Huth 0x8080800080808080ull, /* EF */ 1449fcf5ef2aSThomas Huth 0x8080808000000000ull, /* F0 */ 1450fcf5ef2aSThomas Huth 0x8080808000000080ull, /* F1 */ 1451fcf5ef2aSThomas Huth 0x8080808000008000ull, /* F2 */ 1452fcf5ef2aSThomas Huth 0x8080808000008080ull, /* F3 */ 1453fcf5ef2aSThomas Huth 0x8080808000800000ull, /* F4 */ 1454fcf5ef2aSThomas Huth 0x8080808000800080ull, /* F5 */ 1455fcf5ef2aSThomas Huth 0x8080808000808000ull, /* F6 */ 1456fcf5ef2aSThomas Huth 0x8080808000808080ull, /* F7 */ 1457fcf5ef2aSThomas Huth 0x8080808080000000ull, /* F8 */ 1458fcf5ef2aSThomas Huth 0x8080808080000080ull, /* F9 */ 1459fcf5ef2aSThomas Huth 0x8080808080008000ull, /* FA */ 1460fcf5ef2aSThomas Huth 0x8080808080008080ull, /* FB */ 1461fcf5ef2aSThomas Huth 0x8080808080800000ull, /* FC */ 1462fcf5ef2aSThomas Huth 0x8080808080800080ull, /* FD */ 1463fcf5ef2aSThomas Huth 0x8080808080808000ull, /* FE */ 1464fcf5ef2aSThomas Huth 0x8080808080808080ull, /* FF */ 1465fcf5ef2aSThomas Huth }; 1466fcf5ef2aSThomas Huth 1467fcf5ef2aSThomas Huth void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b) 1468fcf5ef2aSThomas Huth { 1469fcf5ef2aSThomas Huth int i; 1470fcf5ef2aSThomas Huth uint64_t t[2] = { 0, 0 }; 1471fcf5ef2aSThomas Huth 1472fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1473fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1474fcf5ef2aSThomas Huth t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7); 1475fcf5ef2aSThomas Huth #else 1476fcf5ef2aSThomas Huth t[i >> 3] |= VGBBD_MASKS[b->u8[i]] >> (7 - (i & 7)); 1477fcf5ef2aSThomas Huth #endif 1478fcf5ef2aSThomas Huth } 1479fcf5ef2aSThomas Huth 1480fcf5ef2aSThomas Huth r->u64[0] = t[0]; 1481fcf5ef2aSThomas Huth r->u64[1] = t[1]; 1482fcf5ef2aSThomas Huth } 1483fcf5ef2aSThomas Huth 1484fcf5ef2aSThomas Huth #define PMSUM(name, srcfld, trgfld, trgtyp) \ 1485fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1486fcf5ef2aSThomas Huth { \ 1487fcf5ef2aSThomas Huth int i, j; \ 1488fcf5ef2aSThomas Huth trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])]; \ 1489fcf5ef2aSThomas Huth \ 1490fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, srcfld) { \ 1491fcf5ef2aSThomas Huth prod[i] = 0; \ 1492fcf5ef2aSThomas Huth for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \ 1493fcf5ef2aSThomas Huth if (a->srcfld[i] & (1ull << j)) { \ 1494fcf5ef2aSThomas Huth prod[i] ^= ((trgtyp)b->srcfld[i] << j); \ 1495fcf5ef2aSThomas Huth } \ 1496fcf5ef2aSThomas Huth } \ 1497fcf5ef2aSThomas Huth } \ 1498fcf5ef2aSThomas Huth \ 1499fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, trgfld) { \ 1500fcf5ef2aSThomas Huth r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1]; \ 1501fcf5ef2aSThomas Huth } \ 1502fcf5ef2aSThomas Huth } 1503fcf5ef2aSThomas Huth 1504fcf5ef2aSThomas Huth PMSUM(vpmsumb, u8, u16, uint16_t) 1505fcf5ef2aSThomas Huth PMSUM(vpmsumh, u16, u32, uint32_t) 1506fcf5ef2aSThomas Huth PMSUM(vpmsumw, u32, u64, uint64_t) 1507fcf5ef2aSThomas Huth 1508fcf5ef2aSThomas Huth void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1509fcf5ef2aSThomas Huth { 1510fcf5ef2aSThomas Huth 1511fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1512fcf5ef2aSThomas Huth int i, j; 1513fcf5ef2aSThomas Huth __uint128_t prod[2]; 1514fcf5ef2aSThomas Huth 1515fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1516fcf5ef2aSThomas Huth prod[i] = 0; 1517fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1518fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1519fcf5ef2aSThomas Huth prod[i] ^= (((__uint128_t)b->u64[i]) << j); 1520fcf5ef2aSThomas Huth } 1521fcf5ef2aSThomas Huth } 1522fcf5ef2aSThomas Huth } 1523fcf5ef2aSThomas Huth 1524fcf5ef2aSThomas Huth r->u128 = prod[0] ^ prod[1]; 1525fcf5ef2aSThomas Huth 1526fcf5ef2aSThomas Huth #else 1527fcf5ef2aSThomas Huth int i, j; 1528fcf5ef2aSThomas Huth ppc_avr_t prod[2]; 1529fcf5ef2aSThomas Huth 1530fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 15313c385a93SMark Cave-Ayland prod[i].VsrD(1) = prod[i].VsrD(0) = 0; 1532fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1533fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1534fcf5ef2aSThomas Huth ppc_avr_t bshift; 1535fcf5ef2aSThomas Huth if (j == 0) { 15363c385a93SMark Cave-Ayland bshift.VsrD(0) = 0; 15373c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i]; 1538fcf5ef2aSThomas Huth } else { 15393c385a93SMark Cave-Ayland bshift.VsrD(0) = b->u64[i] >> (64 - j); 15403c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i] << j; 1541fcf5ef2aSThomas Huth } 15423c385a93SMark Cave-Ayland prod[i].VsrD(1) ^= bshift.VsrD(1); 15433c385a93SMark Cave-Ayland prod[i].VsrD(0) ^= bshift.VsrD(0); 1544fcf5ef2aSThomas Huth } 1545fcf5ef2aSThomas Huth } 1546fcf5ef2aSThomas Huth } 1547fcf5ef2aSThomas Huth 15483c385a93SMark Cave-Ayland r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1); 15493c385a93SMark Cave-Ayland r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0); 1550fcf5ef2aSThomas Huth #endif 1551fcf5ef2aSThomas Huth } 1552fcf5ef2aSThomas Huth 1553fcf5ef2aSThomas Huth 1554fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1555fcf5ef2aSThomas Huth #define PKBIG 1 1556fcf5ef2aSThomas Huth #else 1557fcf5ef2aSThomas Huth #define PKBIG 0 1558fcf5ef2aSThomas Huth #endif 1559fcf5ef2aSThomas Huth void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1560fcf5ef2aSThomas Huth { 1561fcf5ef2aSThomas Huth int i, j; 1562fcf5ef2aSThomas Huth ppc_avr_t result; 1563fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1564fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { a, b }; 1565fcf5ef2aSThomas Huth #else 1566fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { b, a }; 1567fcf5ef2aSThomas Huth #endif 1568fcf5ef2aSThomas Huth 1569fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1570fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(j, u32) { 1571fcf5ef2aSThomas Huth uint32_t e = x[i]->u32[j]; 1572fcf5ef2aSThomas Huth 1573fcf5ef2aSThomas Huth result.u16[4 * i + j] = (((e >> 9) & 0xfc00) | 1574fcf5ef2aSThomas Huth ((e >> 6) & 0x3e0) | 1575fcf5ef2aSThomas Huth ((e >> 3) & 0x1f)); 1576fcf5ef2aSThomas Huth } 1577fcf5ef2aSThomas Huth } 1578fcf5ef2aSThomas Huth *r = result; 1579fcf5ef2aSThomas Huth } 1580fcf5ef2aSThomas Huth 1581fcf5ef2aSThomas Huth #define VPK(suffix, from, to, cvt, dosat) \ 1582fcf5ef2aSThomas Huth void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1583fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 1584fcf5ef2aSThomas Huth { \ 1585fcf5ef2aSThomas Huth int i; \ 1586fcf5ef2aSThomas Huth int sat = 0; \ 1587fcf5ef2aSThomas Huth ppc_avr_t result; \ 1588fcf5ef2aSThomas Huth ppc_avr_t *a0 = PKBIG ? a : b; \ 1589fcf5ef2aSThomas Huth ppc_avr_t *a1 = PKBIG ? b : a; \ 1590fcf5ef2aSThomas Huth \ 1591fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, from) { \ 1592fcf5ef2aSThomas Huth result.to[i] = cvt(a0->from[i], &sat); \ 1593fcf5ef2aSThomas Huth result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\ 1594fcf5ef2aSThomas Huth } \ 1595fcf5ef2aSThomas Huth *r = result; \ 1596fcf5ef2aSThomas Huth if (dosat && sat) { \ 15976175f5a0SRichard Henderson set_vscr_sat(env); \ 1598fcf5ef2aSThomas Huth } \ 1599fcf5ef2aSThomas Huth } 1600fcf5ef2aSThomas Huth #define I(x, y) (x) 1601fcf5ef2aSThomas Huth VPK(shss, s16, s8, cvtshsb, 1) 1602fcf5ef2aSThomas Huth VPK(shus, s16, u8, cvtshub, 1) 1603fcf5ef2aSThomas Huth VPK(swss, s32, s16, cvtswsh, 1) 1604fcf5ef2aSThomas Huth VPK(swus, s32, u16, cvtswuh, 1) 1605fcf5ef2aSThomas Huth VPK(sdss, s64, s32, cvtsdsw, 1) 1606fcf5ef2aSThomas Huth VPK(sdus, s64, u32, cvtsduw, 1) 1607fcf5ef2aSThomas Huth VPK(uhus, u16, u8, cvtuhub, 1) 1608fcf5ef2aSThomas Huth VPK(uwus, u32, u16, cvtuwuh, 1) 1609fcf5ef2aSThomas Huth VPK(udus, u64, u32, cvtuduw, 1) 1610fcf5ef2aSThomas Huth VPK(uhum, u16, u8, I, 0) 1611fcf5ef2aSThomas Huth VPK(uwum, u32, u16, I, 0) 1612fcf5ef2aSThomas Huth VPK(udum, u64, u32, I, 0) 1613fcf5ef2aSThomas Huth #undef I 1614fcf5ef2aSThomas Huth #undef VPK 1615fcf5ef2aSThomas Huth #undef PKBIG 1616fcf5ef2aSThomas Huth 1617fcf5ef2aSThomas Huth void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1618fcf5ef2aSThomas Huth { 1619fcf5ef2aSThomas Huth int i; 1620fcf5ef2aSThomas Huth 162105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 162205ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status); 1623fcf5ef2aSThomas Huth } 1624fcf5ef2aSThomas Huth } 1625fcf5ef2aSThomas Huth 1626fcf5ef2aSThomas Huth #define VRFI(suffix, rounding) \ 1627fcf5ef2aSThomas Huth void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1628fcf5ef2aSThomas Huth ppc_avr_t *b) \ 1629fcf5ef2aSThomas Huth { \ 1630fcf5ef2aSThomas Huth int i; \ 1631fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 1632fcf5ef2aSThomas Huth \ 1633fcf5ef2aSThomas Huth set_float_rounding_mode(rounding, &s); \ 163405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 163505ee3e8aSMark Cave-Ayland r->f32[i] = float32_round_to_int (b->f32[i], &s); \ 1636fcf5ef2aSThomas Huth } \ 1637fcf5ef2aSThomas Huth } 1638fcf5ef2aSThomas Huth VRFI(n, float_round_nearest_even) 1639fcf5ef2aSThomas Huth VRFI(m, float_round_down) 1640fcf5ef2aSThomas Huth VRFI(p, float_round_up) 1641fcf5ef2aSThomas Huth VRFI(z, float_round_to_zero) 1642fcf5ef2aSThomas Huth #undef VRFI 1643fcf5ef2aSThomas Huth 1644fcf5ef2aSThomas Huth #define VROTATE(suffix, element, mask) \ 1645fcf5ef2aSThomas Huth void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1646fcf5ef2aSThomas Huth { \ 1647fcf5ef2aSThomas Huth int i; \ 1648fcf5ef2aSThomas Huth \ 1649fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1650fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1651fcf5ef2aSThomas Huth r->element[i] = (a->element[i] << shift) | \ 1652fcf5ef2aSThomas Huth (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \ 1653fcf5ef2aSThomas Huth } \ 1654fcf5ef2aSThomas Huth } 1655fcf5ef2aSThomas Huth VROTATE(b, u8, 0x7) 1656fcf5ef2aSThomas Huth VROTATE(h, u16, 0xF) 1657fcf5ef2aSThomas Huth VROTATE(w, u32, 0x1F) 1658fcf5ef2aSThomas Huth VROTATE(d, u64, 0x3F) 1659fcf5ef2aSThomas Huth #undef VROTATE 1660fcf5ef2aSThomas Huth 1661fcf5ef2aSThomas Huth void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1662fcf5ef2aSThomas Huth { 1663fcf5ef2aSThomas Huth int i; 1664fcf5ef2aSThomas Huth 166505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 166605ee3e8aSMark Cave-Ayland float32 t = float32_sqrt(b->f32[i], &env->vec_status); 1667fcf5ef2aSThomas Huth 166805ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, t, &env->vec_status); 1669fcf5ef2aSThomas Huth } 1670fcf5ef2aSThomas Huth } 1671fcf5ef2aSThomas Huth 1672fcf5ef2aSThomas Huth #define VRLMI(name, size, element, insert) \ 1673fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1674fcf5ef2aSThomas Huth { \ 1675fcf5ef2aSThomas Huth int i; \ 1676fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1677fcf5ef2aSThomas Huth uint##size##_t src1 = a->element[i]; \ 1678fcf5ef2aSThomas Huth uint##size##_t src2 = b->element[i]; \ 1679fcf5ef2aSThomas Huth uint##size##_t src3 = r->element[i]; \ 1680fcf5ef2aSThomas Huth uint##size##_t begin, end, shift, mask, rot_val; \ 1681fcf5ef2aSThomas Huth \ 1682fcf5ef2aSThomas Huth shift = extract##size(src2, 0, 6); \ 1683fcf5ef2aSThomas Huth end = extract##size(src2, 8, 6); \ 1684fcf5ef2aSThomas Huth begin = extract##size(src2, 16, 6); \ 1685fcf5ef2aSThomas Huth rot_val = rol##size(src1, shift); \ 1686fcf5ef2aSThomas Huth mask = mask_u##size(begin, end); \ 1687fcf5ef2aSThomas Huth if (insert) { \ 1688fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask) | (src3 & ~mask); \ 1689fcf5ef2aSThomas Huth } else { \ 1690fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask); \ 1691fcf5ef2aSThomas Huth } \ 1692fcf5ef2aSThomas Huth } \ 1693fcf5ef2aSThomas Huth } 1694fcf5ef2aSThomas Huth 1695fcf5ef2aSThomas Huth VRLMI(vrldmi, 64, u64, 1); 1696fcf5ef2aSThomas Huth VRLMI(vrlwmi, 32, u32, 1); 1697fcf5ef2aSThomas Huth VRLMI(vrldnm, 64, u64, 0); 1698fcf5ef2aSThomas Huth VRLMI(vrlwnm, 32, u32, 0); 1699fcf5ef2aSThomas Huth 1700fcf5ef2aSThomas Huth void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1701fcf5ef2aSThomas Huth ppc_avr_t *c) 1702fcf5ef2aSThomas Huth { 1703fcf5ef2aSThomas Huth r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]); 1704fcf5ef2aSThomas Huth r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]); 1705fcf5ef2aSThomas Huth } 1706fcf5ef2aSThomas Huth 1707fcf5ef2aSThomas Huth void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1708fcf5ef2aSThomas Huth { 1709fcf5ef2aSThomas Huth int i; 1710fcf5ef2aSThomas Huth 171105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 171205ee3e8aSMark Cave-Ayland r->f32[i] = float32_exp2(b->f32[i], &env->vec_status); 1713fcf5ef2aSThomas Huth } 1714fcf5ef2aSThomas Huth } 1715fcf5ef2aSThomas Huth 1716fcf5ef2aSThomas Huth void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1717fcf5ef2aSThomas Huth { 1718fcf5ef2aSThomas Huth int i; 1719fcf5ef2aSThomas Huth 172005ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 172105ee3e8aSMark Cave-Ayland r->f32[i] = float32_log2(b->f32[i], &env->vec_status); 1722fcf5ef2aSThomas Huth } 1723fcf5ef2aSThomas Huth } 1724fcf5ef2aSThomas Huth 172560caf221SAvinesh Kumar #if defined(HOST_WORDS_BIGENDIAN) 172660caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 172760caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 172860caf221SAvinesh Kumar { \ 172960caf221SAvinesh Kumar int index; \ 173060caf221SAvinesh Kumar if (left) { \ 173160caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 173260caf221SAvinesh Kumar } else { \ 173360caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 173460caf221SAvinesh Kumar } \ 173560caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 173660caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 173760caf221SAvinesh Kumar } 173860caf221SAvinesh Kumar #else 173960caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 174060caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 174160caf221SAvinesh Kumar { \ 174260caf221SAvinesh Kumar int index; \ 174360caf221SAvinesh Kumar if (left) { \ 174460caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 174560caf221SAvinesh Kumar } else { \ 174660caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 174760caf221SAvinesh Kumar } \ 174860caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 174960caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 175060caf221SAvinesh Kumar } 175160caf221SAvinesh Kumar #endif 175260caf221SAvinesh Kumar 175360caf221SAvinesh Kumar VEXTU_X_DO(vextublx, 8, 1) 175460caf221SAvinesh Kumar VEXTU_X_DO(vextuhlx, 16, 1) 175560caf221SAvinesh Kumar VEXTU_X_DO(vextuwlx, 32, 1) 175660caf221SAvinesh Kumar VEXTU_X_DO(vextubrx, 8, 0) 175760caf221SAvinesh Kumar VEXTU_X_DO(vextuhrx, 16, 0) 175860caf221SAvinesh Kumar VEXTU_X_DO(vextuwrx, 32, 0) 175960caf221SAvinesh Kumar #undef VEXTU_X_DO 176060caf221SAvinesh Kumar 1761b6cb41b2SDavid Gibson /* 1762b6cb41b2SDavid Gibson * The specification says that the results are undefined if all of the 1763b6cb41b2SDavid Gibson * shift counts are not identical. We check to make sure that they 1764b6cb41b2SDavid Gibson * are to conform to what real hardware appears to do. 1765b6cb41b2SDavid Gibson */ 1766fcf5ef2aSThomas Huth #define VSHIFT(suffix, leftp) \ 1767fcf5ef2aSThomas Huth void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1768fcf5ef2aSThomas Huth { \ 17693c385a93SMark Cave-Ayland int shift = b->VsrB(15) & 0x7; \ 1770fcf5ef2aSThomas Huth int doit = 1; \ 1771fcf5ef2aSThomas Huth int i; \ 1772fcf5ef2aSThomas Huth \ 1773fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { \ 1774fcf5ef2aSThomas Huth doit = doit && ((b->u8[i] & 0x7) == shift); \ 1775fcf5ef2aSThomas Huth } \ 1776fcf5ef2aSThomas Huth if (doit) { \ 1777fcf5ef2aSThomas Huth if (shift == 0) { \ 1778fcf5ef2aSThomas Huth *r = *a; \ 1779fcf5ef2aSThomas Huth } else if (leftp) { \ 17803c385a93SMark Cave-Ayland uint64_t carry = a->VsrD(1) >> (64 - shift); \ 1781fcf5ef2aSThomas Huth \ 17823c385a93SMark Cave-Ayland r->VsrD(0) = (a->VsrD(0) << shift) | carry; \ 17833c385a93SMark Cave-Ayland r->VsrD(1) = a->VsrD(1) << shift; \ 1784fcf5ef2aSThomas Huth } else { \ 17853c385a93SMark Cave-Ayland uint64_t carry = a->VsrD(0) << (64 - shift); \ 1786fcf5ef2aSThomas Huth \ 17873c385a93SMark Cave-Ayland r->VsrD(1) = (a->VsrD(1) >> shift) | carry; \ 17883c385a93SMark Cave-Ayland r->VsrD(0) = a->VsrD(0) >> shift; \ 1789fcf5ef2aSThomas Huth } \ 1790fcf5ef2aSThomas Huth } \ 1791fcf5ef2aSThomas Huth } 1792fcf5ef2aSThomas Huth VSHIFT(l, 1) 1793fcf5ef2aSThomas Huth VSHIFT(r, 0) 1794fcf5ef2aSThomas Huth #undef VSHIFT 1795fcf5ef2aSThomas Huth 1796fcf5ef2aSThomas Huth void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1797fcf5ef2aSThomas Huth { 1798fcf5ef2aSThomas Huth int i; 1799fcf5ef2aSThomas Huth unsigned int shift, bytes, size; 1800fcf5ef2aSThomas Huth 1801fcf5ef2aSThomas Huth size = ARRAY_SIZE(r->u8); 1802fcf5ef2aSThomas Huth for (i = 0; i < size; i++) { 180363be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 180463be02fcSAnton Blanchard bytes = (a->VsrB(i) << 8) + /* extract adjacent bytes */ 180563be02fcSAnton Blanchard (((i + 1) < size) ? a->VsrB(i + 1) : 0); 180663be02fcSAnton Blanchard r->VsrB(i) = (bytes << shift) >> 8; /* shift and store result */ 1807fcf5ef2aSThomas Huth } 1808fcf5ef2aSThomas Huth } 1809fcf5ef2aSThomas Huth 1810fcf5ef2aSThomas Huth void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1811fcf5ef2aSThomas Huth { 1812fcf5ef2aSThomas Huth int i; 1813fcf5ef2aSThomas Huth unsigned int shift, bytes; 1814fcf5ef2aSThomas Huth 1815b6cb41b2SDavid Gibson /* 1816b6cb41b2SDavid Gibson * Use reverse order, as destination and source register can be 1817b6cb41b2SDavid Gibson * same. Its being modified in place saving temporary, reverse 1818b6cb41b2SDavid Gibson * order will guarantee that computed result is not fed back. 1819fcf5ef2aSThomas Huth */ 1820fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 182163be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 182263be02fcSAnton Blanchard bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i); 1823fcf5ef2aSThomas Huth /* extract adjacent bytes */ 182463be02fcSAnton Blanchard r->VsrB(i) = (bytes >> shift) & 0xFF; /* shift and store result */ 1825fcf5ef2aSThomas Huth } 1826fcf5ef2aSThomas Huth } 1827fcf5ef2aSThomas Huth 1828fcf5ef2aSThomas Huth void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift) 1829fcf5ef2aSThomas Huth { 1830fcf5ef2aSThomas Huth int sh = shift & 0xf; 1831fcf5ef2aSThomas Huth int i; 1832fcf5ef2aSThomas Huth ppc_avr_t result; 1833fcf5ef2aSThomas Huth 1834fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1835fcf5ef2aSThomas Huth int index = sh + i; 1836fcf5ef2aSThomas Huth if (index > 0xf) { 183760594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index - 0x10); 1838fcf5ef2aSThomas Huth } else { 183960594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1840fcf5ef2aSThomas Huth } 1841fcf5ef2aSThomas Huth } 1842fcf5ef2aSThomas Huth *r = result; 1843fcf5ef2aSThomas Huth } 1844fcf5ef2aSThomas Huth 1845fcf5ef2aSThomas Huth void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1846fcf5ef2aSThomas Huth { 18473c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1848fcf5ef2aSThomas Huth 1849fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1850fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1851fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1852fcf5ef2aSThomas Huth #else 1853fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1854fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1855fcf5ef2aSThomas Huth #endif 1856fcf5ef2aSThomas Huth } 1857fcf5ef2aSThomas Huth 1858fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1859fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1860fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1861fcf5ef2aSThomas Huth { \ 18624fff7218SLaurent Vivier memmove(&r->u8[index], &b->u8[8 - sizeof(r->element[0])], \ 1863fcf5ef2aSThomas Huth sizeof(r->element[0])); \ 1864fcf5ef2aSThomas Huth } 1865fcf5ef2aSThomas Huth #else 1866fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1867fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1868fcf5ef2aSThomas Huth { \ 1869fcf5ef2aSThomas Huth uint32_t d = (16 - index) - sizeof(r->element[0]); \ 1870fcf5ef2aSThomas Huth memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0])); \ 1871fcf5ef2aSThomas Huth } 1872fcf5ef2aSThomas Huth #endif 1873fcf5ef2aSThomas Huth VINSERT(b, u8) 1874fcf5ef2aSThomas Huth VINSERT(h, u16) 1875fcf5ef2aSThomas Huth VINSERT(w, u32) 1876fcf5ef2aSThomas Huth VINSERT(d, u64) 1877fcf5ef2aSThomas Huth #undef VINSERT 1878fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1879fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1880fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1881fcf5ef2aSThomas Huth { \ 1882fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1883fcf5ef2aSThomas Huth memmove(&r->u8[8 - es], &b->u8[index], es); \ 1884fcf5ef2aSThomas Huth memset(&r->u8[8], 0, 8); \ 1885fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8 - es); \ 1886fcf5ef2aSThomas Huth } 1887fcf5ef2aSThomas Huth #else 1888fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1889fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1890fcf5ef2aSThomas Huth { \ 1891fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1892fcf5ef2aSThomas Huth uint32_t s = (16 - index) - es; \ 1893fcf5ef2aSThomas Huth memmove(&r->u8[8], &b->u8[s], es); \ 1894fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8); \ 1895fcf5ef2aSThomas Huth memset(&r->u8[8 + es], 0, 8 - es); \ 1896fcf5ef2aSThomas Huth } 1897fcf5ef2aSThomas Huth #endif 1898fcf5ef2aSThomas Huth VEXTRACT(ub, u8) 1899fcf5ef2aSThomas Huth VEXTRACT(uh, u16) 1900fcf5ef2aSThomas Huth VEXTRACT(uw, u32) 1901fcf5ef2aSThomas Huth VEXTRACT(d, u64) 1902fcf5ef2aSThomas Huth #undef VEXTRACT 1903fcf5ef2aSThomas Huth 19045ba5335dSMark Cave-Ayland void helper_xxextractuw(CPUPPCState *env, ppc_vsr_t *xt, 19055ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 19068ad901e5SNikunj A Dadhania { 190703b32c09SMark Cave-Ayland ppc_vsr_t t = { }; 19088ad901e5SNikunj A Dadhania size_t es = sizeof(uint32_t); 19098ad901e5SNikunj A Dadhania uint32_t ext_index; 19108ad901e5SNikunj A Dadhania int i; 19118ad901e5SNikunj A Dadhania 19128ad901e5SNikunj A Dadhania ext_index = index; 19138ad901e5SNikunj A Dadhania for (i = 0; i < es; i++, ext_index++) { 191403b32c09SMark Cave-Ayland t.VsrB(8 - es + i) = xb->VsrB(ext_index % 16); 19158ad901e5SNikunj A Dadhania } 19168ad901e5SNikunj A Dadhania 191703b32c09SMark Cave-Ayland *xt = t; 19188ad901e5SNikunj A Dadhania } 19198ad901e5SNikunj A Dadhania 19205ba5335dSMark Cave-Ayland void helper_xxinsertw(CPUPPCState *env, ppc_vsr_t *xt, 19215ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 19223398b742SNikunj A Dadhania { 192303b32c09SMark Cave-Ayland ppc_vsr_t t = *xt; 19243398b742SNikunj A Dadhania size_t es = sizeof(uint32_t); 19253398b742SNikunj A Dadhania int ins_index, i = 0; 19263398b742SNikunj A Dadhania 19273398b742SNikunj A Dadhania ins_index = index; 19283398b742SNikunj A Dadhania for (i = 0; i < es && ins_index < 16; i++, ins_index++) { 192903b32c09SMark Cave-Ayland t.VsrB(ins_index) = xb->VsrB(8 - es + i); 19303398b742SNikunj A Dadhania } 19313398b742SNikunj A Dadhania 193203b32c09SMark Cave-Ayland *xt = t; 19333398b742SNikunj A Dadhania } 19343398b742SNikunj A Dadhania 1935634c5835SMark Cave-Ayland #define VEXT_SIGNED(name, element, cast) \ 1936fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1937fcf5ef2aSThomas Huth { \ 1938fcf5ef2aSThomas Huth int i; \ 193960594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1940634c5835SMark Cave-Ayland r->element[i] = (cast)b->element[i]; \ 1941fcf5ef2aSThomas Huth } \ 1942fcf5ef2aSThomas Huth } 1943634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2w, s32, int8_t) 1944634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2d, s64, int8_t) 1945634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2w, s32, int16_t) 1946634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2d, s64, int16_t) 1947634c5835SMark Cave-Ayland VEXT_SIGNED(vextsw2d, s64, int32_t) 1948fcf5ef2aSThomas Huth #undef VEXT_SIGNED 1949fcf5ef2aSThomas Huth 1950fcf5ef2aSThomas Huth #define VNEG(name, element) \ 1951fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1952fcf5ef2aSThomas Huth { \ 1953fcf5ef2aSThomas Huth int i; \ 195460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1955fcf5ef2aSThomas Huth r->element[i] = -b->element[i]; \ 1956fcf5ef2aSThomas Huth } \ 1957fcf5ef2aSThomas Huth } 1958fcf5ef2aSThomas Huth VNEG(vnegw, s32) 1959fcf5ef2aSThomas Huth VNEG(vnegd, s64) 1960fcf5ef2aSThomas Huth #undef VNEG 1961fcf5ef2aSThomas Huth 1962fcf5ef2aSThomas Huth void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1963fcf5ef2aSThomas Huth { 19643c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1965fcf5ef2aSThomas Huth 1966fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1967fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1968fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1969fcf5ef2aSThomas Huth #else 1970fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1971fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1972fcf5ef2aSThomas Huth #endif 1973fcf5ef2aSThomas Huth } 1974fcf5ef2aSThomas Huth 1975fcf5ef2aSThomas Huth void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1976fcf5ef2aSThomas Huth { 1977fcf5ef2aSThomas Huth int i; 1978fcf5ef2aSThomas Huth 1979fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 1980fcf5ef2aSThomas Huth r->u32[i] = a->u32[i] >= b->u32[i]; 1981fcf5ef2aSThomas Huth } 1982fcf5ef2aSThomas Huth } 1983fcf5ef2aSThomas Huth 1984fcf5ef2aSThomas Huth void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1985fcf5ef2aSThomas Huth { 1986fcf5ef2aSThomas Huth int64_t t; 1987fcf5ef2aSThomas Huth int i, upper; 1988fcf5ef2aSThomas Huth ppc_avr_t result; 1989fcf5ef2aSThomas Huth int sat = 0; 1990fcf5ef2aSThomas Huth 1991fcf5ef2aSThomas Huth upper = ARRAY_SIZE(r->s32) - 1; 199260594feaSMark Cave-Ayland t = (int64_t)b->VsrSW(upper); 1993fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 199460594feaSMark Cave-Ayland t += a->VsrSW(i); 199560594feaSMark Cave-Ayland result.VsrSW(i) = 0; 1996fcf5ef2aSThomas Huth } 199760594feaSMark Cave-Ayland result.VsrSW(upper) = cvtsdsw(t, &sat); 1998fcf5ef2aSThomas Huth *r = result; 1999fcf5ef2aSThomas Huth 2000fcf5ef2aSThomas Huth if (sat) { 20016175f5a0SRichard Henderson set_vscr_sat(env); 2002fcf5ef2aSThomas Huth } 2003fcf5ef2aSThomas Huth } 2004fcf5ef2aSThomas Huth 2005fcf5ef2aSThomas Huth void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2006fcf5ef2aSThomas Huth { 2007fcf5ef2aSThomas Huth int i, j, upper; 2008fcf5ef2aSThomas Huth ppc_avr_t result; 2009fcf5ef2aSThomas Huth int sat = 0; 2010fcf5ef2aSThomas Huth 2011fcf5ef2aSThomas Huth upper = 1; 2012fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 201360594feaSMark Cave-Ayland int64_t t = (int64_t)b->VsrSW(upper + i * 2); 2014fcf5ef2aSThomas Huth 20157fa0ddc1SAnton Blanchard result.VsrD(i) = 0; 2016fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u64); j++) { 201760594feaSMark Cave-Ayland t += a->VsrSW(2 * i + j); 2018fcf5ef2aSThomas Huth } 201960594feaSMark Cave-Ayland result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat); 2020fcf5ef2aSThomas Huth } 2021fcf5ef2aSThomas Huth 2022fcf5ef2aSThomas Huth *r = result; 2023fcf5ef2aSThomas Huth if (sat) { 20246175f5a0SRichard Henderson set_vscr_sat(env); 2025fcf5ef2aSThomas Huth } 2026fcf5ef2aSThomas Huth } 2027fcf5ef2aSThomas Huth 2028fcf5ef2aSThomas Huth void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2029fcf5ef2aSThomas Huth { 2030fcf5ef2aSThomas Huth int i, j; 2031fcf5ef2aSThomas Huth int sat = 0; 2032fcf5ef2aSThomas Huth 2033fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2034fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2035fcf5ef2aSThomas Huth 2036fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->s32); j++) { 2037fcf5ef2aSThomas Huth t += a->s8[4 * i + j]; 2038fcf5ef2aSThomas Huth } 2039fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2040fcf5ef2aSThomas Huth } 2041fcf5ef2aSThomas Huth 2042fcf5ef2aSThomas Huth if (sat) { 20436175f5a0SRichard Henderson set_vscr_sat(env); 2044fcf5ef2aSThomas Huth } 2045fcf5ef2aSThomas Huth } 2046fcf5ef2aSThomas Huth 2047fcf5ef2aSThomas Huth void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2048fcf5ef2aSThomas Huth { 2049fcf5ef2aSThomas Huth int sat = 0; 2050fcf5ef2aSThomas Huth int i; 2051fcf5ef2aSThomas Huth 2052fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2053fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2054fcf5ef2aSThomas Huth 2055fcf5ef2aSThomas Huth t += a->s16[2 * i] + a->s16[2 * i + 1]; 2056fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2057fcf5ef2aSThomas Huth } 2058fcf5ef2aSThomas Huth 2059fcf5ef2aSThomas Huth if (sat) { 20606175f5a0SRichard Henderson set_vscr_sat(env); 2061fcf5ef2aSThomas Huth } 2062fcf5ef2aSThomas Huth } 2063fcf5ef2aSThomas Huth 2064fcf5ef2aSThomas Huth void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2065fcf5ef2aSThomas Huth { 2066fcf5ef2aSThomas Huth int i, j; 2067fcf5ef2aSThomas Huth int sat = 0; 2068fcf5ef2aSThomas Huth 2069fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2070fcf5ef2aSThomas Huth uint64_t t = (uint64_t)b->u32[i]; 2071fcf5ef2aSThomas Huth 2072fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u32); j++) { 2073fcf5ef2aSThomas Huth t += a->u8[4 * i + j]; 2074fcf5ef2aSThomas Huth } 2075fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 2076fcf5ef2aSThomas Huth } 2077fcf5ef2aSThomas Huth 2078fcf5ef2aSThomas Huth if (sat) { 20796175f5a0SRichard Henderson set_vscr_sat(env); 2080fcf5ef2aSThomas Huth } 2081fcf5ef2aSThomas Huth } 2082fcf5ef2aSThomas Huth 2083fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2084fcf5ef2aSThomas Huth #define UPKHI 1 2085fcf5ef2aSThomas Huth #define UPKLO 0 2086fcf5ef2aSThomas Huth #else 2087fcf5ef2aSThomas Huth #define UPKHI 0 2088fcf5ef2aSThomas Huth #define UPKLO 1 2089fcf5ef2aSThomas Huth #endif 2090fcf5ef2aSThomas Huth #define VUPKPX(suffix, hi) \ 2091fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2092fcf5ef2aSThomas Huth { \ 2093fcf5ef2aSThomas Huth int i; \ 2094fcf5ef2aSThomas Huth ppc_avr_t result; \ 2095fcf5ef2aSThomas Huth \ 2096fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \ 2097fcf5ef2aSThomas Huth uint16_t e = b->u16[hi ? i : i + 4]; \ 2098fcf5ef2aSThomas Huth uint8_t a = (e >> 15) ? 0xff : 0; \ 2099fcf5ef2aSThomas Huth uint8_t r = (e >> 10) & 0x1f; \ 2100fcf5ef2aSThomas Huth uint8_t g = (e >> 5) & 0x1f; \ 2101fcf5ef2aSThomas Huth uint8_t b = e & 0x1f; \ 2102fcf5ef2aSThomas Huth \ 2103fcf5ef2aSThomas Huth result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \ 2104fcf5ef2aSThomas Huth } \ 2105fcf5ef2aSThomas Huth *r = result; \ 2106fcf5ef2aSThomas Huth } 2107fcf5ef2aSThomas Huth VUPKPX(lpx, UPKLO) 2108fcf5ef2aSThomas Huth VUPKPX(hpx, UPKHI) 2109fcf5ef2aSThomas Huth #undef VUPKPX 2110fcf5ef2aSThomas Huth 2111fcf5ef2aSThomas Huth #define VUPK(suffix, unpacked, packee, hi) \ 2112fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2113fcf5ef2aSThomas Huth { \ 2114fcf5ef2aSThomas Huth int i; \ 2115fcf5ef2aSThomas Huth ppc_avr_t result; \ 2116fcf5ef2aSThomas Huth \ 2117fcf5ef2aSThomas Huth if (hi) { \ 2118fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \ 2119fcf5ef2aSThomas Huth result.unpacked[i] = b->packee[i]; \ 2120fcf5ef2aSThomas Huth } \ 2121fcf5ef2aSThomas Huth } else { \ 2122fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \ 2123fcf5ef2aSThomas Huth i++) { \ 2124fcf5ef2aSThomas Huth result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \ 2125fcf5ef2aSThomas Huth } \ 2126fcf5ef2aSThomas Huth } \ 2127fcf5ef2aSThomas Huth *r = result; \ 2128fcf5ef2aSThomas Huth } 2129fcf5ef2aSThomas Huth VUPK(hsb, s16, s8, UPKHI) 2130fcf5ef2aSThomas Huth VUPK(hsh, s32, s16, UPKHI) 2131fcf5ef2aSThomas Huth VUPK(hsw, s64, s32, UPKHI) 2132fcf5ef2aSThomas Huth VUPK(lsb, s16, s8, UPKLO) 2133fcf5ef2aSThomas Huth VUPK(lsh, s32, s16, UPKLO) 2134fcf5ef2aSThomas Huth VUPK(lsw, s64, s32, UPKLO) 2135fcf5ef2aSThomas Huth #undef VUPK 2136fcf5ef2aSThomas Huth #undef UPKHI 2137fcf5ef2aSThomas Huth #undef UPKLO 2138fcf5ef2aSThomas Huth 2139fcf5ef2aSThomas Huth #define VGENERIC_DO(name, element) \ 2140fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \ 2141fcf5ef2aSThomas Huth { \ 2142fcf5ef2aSThomas Huth int i; \ 2143fcf5ef2aSThomas Huth \ 214460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 2145fcf5ef2aSThomas Huth r->element[i] = name(b->element[i]); \ 2146fcf5ef2aSThomas Huth } \ 2147fcf5ef2aSThomas Huth } 2148fcf5ef2aSThomas Huth 2149fcf5ef2aSThomas Huth #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8) 2150fcf5ef2aSThomas Huth #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16) 2151fcf5ef2aSThomas Huth #define clzw(v) clz32((v)) 2152fcf5ef2aSThomas Huth #define clzd(v) clz64((v)) 2153fcf5ef2aSThomas Huth 2154fcf5ef2aSThomas Huth VGENERIC_DO(clzb, u8) 2155fcf5ef2aSThomas Huth VGENERIC_DO(clzh, u16) 2156fcf5ef2aSThomas Huth VGENERIC_DO(clzw, u32) 2157fcf5ef2aSThomas Huth VGENERIC_DO(clzd, u64) 2158fcf5ef2aSThomas Huth 2159fcf5ef2aSThomas Huth #undef clzb 2160fcf5ef2aSThomas Huth #undef clzh 2161fcf5ef2aSThomas Huth #undef clzw 2162fcf5ef2aSThomas Huth #undef clzd 2163fcf5ef2aSThomas Huth 2164fcf5ef2aSThomas Huth #define ctzb(v) ((v) ? ctz32(v) : 8) 2165fcf5ef2aSThomas Huth #define ctzh(v) ((v) ? ctz32(v) : 16) 2166fcf5ef2aSThomas Huth #define ctzw(v) ctz32((v)) 2167fcf5ef2aSThomas Huth #define ctzd(v) ctz64((v)) 2168fcf5ef2aSThomas Huth 2169fcf5ef2aSThomas Huth VGENERIC_DO(ctzb, u8) 2170fcf5ef2aSThomas Huth VGENERIC_DO(ctzh, u16) 2171fcf5ef2aSThomas Huth VGENERIC_DO(ctzw, u32) 2172fcf5ef2aSThomas Huth VGENERIC_DO(ctzd, u64) 2173fcf5ef2aSThomas Huth 2174fcf5ef2aSThomas Huth #undef ctzb 2175fcf5ef2aSThomas Huth #undef ctzh 2176fcf5ef2aSThomas Huth #undef ctzw 2177fcf5ef2aSThomas Huth #undef ctzd 2178fcf5ef2aSThomas Huth 2179fcf5ef2aSThomas Huth #define popcntb(v) ctpop8(v) 2180fcf5ef2aSThomas Huth #define popcnth(v) ctpop16(v) 2181fcf5ef2aSThomas Huth #define popcntw(v) ctpop32(v) 2182fcf5ef2aSThomas Huth #define popcntd(v) ctpop64(v) 2183fcf5ef2aSThomas Huth 2184fcf5ef2aSThomas Huth VGENERIC_DO(popcntb, u8) 2185fcf5ef2aSThomas Huth VGENERIC_DO(popcnth, u16) 2186fcf5ef2aSThomas Huth VGENERIC_DO(popcntw, u32) 2187fcf5ef2aSThomas Huth VGENERIC_DO(popcntd, u64) 2188fcf5ef2aSThomas Huth 2189fcf5ef2aSThomas Huth #undef popcntb 2190fcf5ef2aSThomas Huth #undef popcnth 2191fcf5ef2aSThomas Huth #undef popcntw 2192fcf5ef2aSThomas Huth #undef popcntd 2193fcf5ef2aSThomas Huth 2194fcf5ef2aSThomas Huth #undef VGENERIC_DO 2195fcf5ef2aSThomas Huth 2196fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2197fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 0, 1 } } 2198fcf5ef2aSThomas Huth #else 2199fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 1, 0 } } 2200fcf5ef2aSThomas Huth #endif 2201fcf5ef2aSThomas Huth 2202fcf5ef2aSThomas Huth #ifndef CONFIG_INT128 2203fcf5ef2aSThomas Huth 2204fcf5ef2aSThomas Huth static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a) 2205fcf5ef2aSThomas Huth { 2206fcf5ef2aSThomas Huth t->u64[0] = ~a.u64[0]; 2207fcf5ef2aSThomas Huth t->u64[1] = ~a.u64[1]; 2208fcf5ef2aSThomas Huth } 2209fcf5ef2aSThomas Huth 2210fcf5ef2aSThomas Huth static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b) 2211fcf5ef2aSThomas Huth { 22123c385a93SMark Cave-Ayland if (a.VsrD(0) < b.VsrD(0)) { 2213fcf5ef2aSThomas Huth return -1; 22143c385a93SMark Cave-Ayland } else if (a.VsrD(0) > b.VsrD(0)) { 2215fcf5ef2aSThomas Huth return 1; 22163c385a93SMark Cave-Ayland } else if (a.VsrD(1) < b.VsrD(1)) { 2217fcf5ef2aSThomas Huth return -1; 22183c385a93SMark Cave-Ayland } else if (a.VsrD(1) > b.VsrD(1)) { 2219fcf5ef2aSThomas Huth return 1; 2220fcf5ef2aSThomas Huth } else { 2221fcf5ef2aSThomas Huth return 0; 2222fcf5ef2aSThomas Huth } 2223fcf5ef2aSThomas Huth } 2224fcf5ef2aSThomas Huth 2225fcf5ef2aSThomas Huth static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2226fcf5ef2aSThomas Huth { 22273c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 22283c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 22293c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 2230fcf5ef2aSThomas Huth } 2231fcf5ef2aSThomas Huth 2232fcf5ef2aSThomas Huth static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2233fcf5ef2aSThomas Huth { 2234fcf5ef2aSThomas Huth ppc_avr_t not_a; 22353c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 22363c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 22373c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 2238fcf5ef2aSThomas Huth avr_qw_not(¬_a, a); 2239fcf5ef2aSThomas Huth return avr_qw_cmpu(not_a, b) < 0; 2240fcf5ef2aSThomas Huth } 2241fcf5ef2aSThomas Huth 2242fcf5ef2aSThomas Huth #endif 2243fcf5ef2aSThomas Huth 2244fcf5ef2aSThomas Huth void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2245fcf5ef2aSThomas Huth { 2246fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2247fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128; 2248fcf5ef2aSThomas Huth #else 2249fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2250fcf5ef2aSThomas Huth #endif 2251fcf5ef2aSThomas Huth } 2252fcf5ef2aSThomas Huth 2253fcf5ef2aSThomas Huth void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2254fcf5ef2aSThomas Huth { 2255fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2256fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128 + (c->u128 & 1); 2257fcf5ef2aSThomas Huth #else 2258fcf5ef2aSThomas Huth 22593c385a93SMark Cave-Ayland if (c->VsrD(1) & 1) { 2260fcf5ef2aSThomas Huth ppc_avr_t tmp; 2261fcf5ef2aSThomas Huth 22623c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 22633c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2264fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2265fcf5ef2aSThomas Huth avr_qw_add(r, tmp, *b); 2266fcf5ef2aSThomas Huth } else { 2267fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2268fcf5ef2aSThomas Huth } 2269fcf5ef2aSThomas Huth #endif 2270fcf5ef2aSThomas Huth } 2271fcf5ef2aSThomas Huth 2272fcf5ef2aSThomas Huth void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2273fcf5ef2aSThomas Huth { 2274fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2275fcf5ef2aSThomas Huth r->u128 = (~a->u128 < b->u128); 2276fcf5ef2aSThomas Huth #else 2277fcf5ef2aSThomas Huth ppc_avr_t not_a; 2278fcf5ef2aSThomas Huth 2279fcf5ef2aSThomas Huth avr_qw_not(¬_a, *a); 2280fcf5ef2aSThomas Huth 22813c385a93SMark Cave-Ayland r->VsrD(0) = 0; 22823c385a93SMark Cave-Ayland r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0); 2283fcf5ef2aSThomas Huth #endif 2284fcf5ef2aSThomas Huth } 2285fcf5ef2aSThomas Huth 2286fcf5ef2aSThomas Huth void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2287fcf5ef2aSThomas Huth { 2288fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2289fcf5ef2aSThomas Huth int carry_out = (~a->u128 < b->u128); 2290fcf5ef2aSThomas Huth if (!carry_out && (c->u128 & 1)) { 2291fcf5ef2aSThomas Huth carry_out = ((a->u128 + b->u128 + 1) == 0) && 2292fcf5ef2aSThomas Huth ((a->u128 != 0) || (b->u128 != 0)); 2293fcf5ef2aSThomas Huth } 2294fcf5ef2aSThomas Huth r->u128 = carry_out; 2295fcf5ef2aSThomas Huth #else 2296fcf5ef2aSThomas Huth 22973c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2298fcf5ef2aSThomas Huth int carry_out = 0; 2299fcf5ef2aSThomas Huth ppc_avr_t tmp; 2300fcf5ef2aSThomas Huth 2301fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, *a, *b); 2302fcf5ef2aSThomas Huth 2303fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2304fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2305fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, tmp, one); 2306fcf5ef2aSThomas Huth } 23073c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23083c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2309fcf5ef2aSThomas Huth #endif 2310fcf5ef2aSThomas Huth } 2311fcf5ef2aSThomas Huth 2312fcf5ef2aSThomas Huth void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2313fcf5ef2aSThomas Huth { 2314fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2315fcf5ef2aSThomas Huth r->u128 = a->u128 - b->u128; 2316fcf5ef2aSThomas Huth #else 2317fcf5ef2aSThomas Huth ppc_avr_t tmp; 2318fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2319fcf5ef2aSThomas Huth 2320fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2321fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2322fcf5ef2aSThomas Huth avr_qw_add(r, tmp, one); 2323fcf5ef2aSThomas Huth #endif 2324fcf5ef2aSThomas Huth } 2325fcf5ef2aSThomas Huth 2326fcf5ef2aSThomas Huth void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2327fcf5ef2aSThomas Huth { 2328fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2329fcf5ef2aSThomas Huth r->u128 = a->u128 + ~b->u128 + (c->u128 & 1); 2330fcf5ef2aSThomas Huth #else 2331fcf5ef2aSThomas Huth ppc_avr_t tmp, sum; 2332fcf5ef2aSThomas Huth 2333fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2334fcf5ef2aSThomas Huth avr_qw_add(&sum, *a, tmp); 2335fcf5ef2aSThomas Huth 23363c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 23373c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2338fcf5ef2aSThomas Huth avr_qw_add(r, sum, tmp); 2339fcf5ef2aSThomas Huth #endif 2340fcf5ef2aSThomas Huth } 2341fcf5ef2aSThomas Huth 2342fcf5ef2aSThomas Huth void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2343fcf5ef2aSThomas Huth { 2344fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2345fcf5ef2aSThomas Huth r->u128 = (~a->u128 < ~b->u128) || 2346fcf5ef2aSThomas Huth (a->u128 + ~b->u128 == (__uint128_t)-1); 2347fcf5ef2aSThomas Huth #else 2348fcf5ef2aSThomas Huth int carry = (avr_qw_cmpu(*a, *b) > 0); 2349fcf5ef2aSThomas Huth if (!carry) { 2350fcf5ef2aSThomas Huth ppc_avr_t tmp; 2351fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2352fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 23533c385a93SMark Cave-Ayland carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull)); 2354fcf5ef2aSThomas Huth } 23553c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23563c385a93SMark Cave-Ayland r->VsrD(1) = carry; 2357fcf5ef2aSThomas Huth #endif 2358fcf5ef2aSThomas Huth } 2359fcf5ef2aSThomas Huth 2360fcf5ef2aSThomas Huth void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2361fcf5ef2aSThomas Huth { 2362fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2363fcf5ef2aSThomas Huth r->u128 = 2364fcf5ef2aSThomas Huth (~a->u128 < ~b->u128) || 2365fcf5ef2aSThomas Huth ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1)); 2366fcf5ef2aSThomas Huth #else 23673c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2368fcf5ef2aSThomas Huth int carry_out = (avr_qw_cmpu(*a, *b) > 0); 2369fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2370fcf5ef2aSThomas Huth ppc_avr_t tmp; 2371fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2372fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 23733c385a93SMark Cave-Ayland carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull)); 2374fcf5ef2aSThomas Huth } 2375fcf5ef2aSThomas Huth 23763c385a93SMark Cave-Ayland r->VsrD(0) = 0; 23773c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2378fcf5ef2aSThomas Huth #endif 2379fcf5ef2aSThomas Huth } 2380fcf5ef2aSThomas Huth 2381fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_1 0xC 2382fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_2 0xF 2383fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_1 0xA 2384fcf5ef2aSThomas Huth #define BCD_NEG_PREF 0xD 2385fcf5ef2aSThomas Huth #define BCD_NEG_ALT 0xB 2386fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_2 0xE 2387fcf5ef2aSThomas Huth #define NATIONAL_PLUS 0x2B 2388fcf5ef2aSThomas Huth #define NATIONAL_NEG 0x2D 2389fcf5ef2aSThomas Huth 2390fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2391365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) (15 - ((n) / 2)) 2392fcf5ef2aSThomas Huth #else 2393365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) ((n) / 2) 2394fcf5ef2aSThomas Huth #endif 2395fcf5ef2aSThomas Huth 2396fcf5ef2aSThomas Huth static int bcd_get_sgn(ppc_avr_t *bcd) 2397fcf5ef2aSThomas Huth { 2398fcf5ef2aSThomas Huth switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) { 2399fcf5ef2aSThomas Huth case BCD_PLUS_PREF_1: 2400fcf5ef2aSThomas Huth case BCD_PLUS_PREF_2: 2401fcf5ef2aSThomas Huth case BCD_PLUS_ALT_1: 2402fcf5ef2aSThomas Huth case BCD_PLUS_ALT_2: 2403fcf5ef2aSThomas Huth { 2404fcf5ef2aSThomas Huth return 1; 2405fcf5ef2aSThomas Huth } 2406fcf5ef2aSThomas Huth 2407fcf5ef2aSThomas Huth case BCD_NEG_PREF: 2408fcf5ef2aSThomas Huth case BCD_NEG_ALT: 2409fcf5ef2aSThomas Huth { 2410fcf5ef2aSThomas Huth return -1; 2411fcf5ef2aSThomas Huth } 2412fcf5ef2aSThomas Huth 2413fcf5ef2aSThomas Huth default: 2414fcf5ef2aSThomas Huth { 2415fcf5ef2aSThomas Huth return 0; 2416fcf5ef2aSThomas Huth } 2417fcf5ef2aSThomas Huth } 2418fcf5ef2aSThomas Huth } 2419fcf5ef2aSThomas Huth 2420fcf5ef2aSThomas Huth static int bcd_preferred_sgn(int sgn, int ps) 2421fcf5ef2aSThomas Huth { 2422fcf5ef2aSThomas Huth if (sgn >= 0) { 2423fcf5ef2aSThomas Huth return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2; 2424fcf5ef2aSThomas Huth } else { 2425fcf5ef2aSThomas Huth return BCD_NEG_PREF; 2426fcf5ef2aSThomas Huth } 2427fcf5ef2aSThomas Huth } 2428fcf5ef2aSThomas Huth 2429fcf5ef2aSThomas Huth static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid) 2430fcf5ef2aSThomas Huth { 2431fcf5ef2aSThomas Huth uint8_t result; 2432fcf5ef2aSThomas Huth if (n & 1) { 2433fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] >> 4; 2434fcf5ef2aSThomas Huth } else { 2435fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF; 2436fcf5ef2aSThomas Huth } 2437fcf5ef2aSThomas Huth 2438fcf5ef2aSThomas Huth if (unlikely(result > 9)) { 2439fcf5ef2aSThomas Huth *invalid = true; 2440fcf5ef2aSThomas Huth } 2441fcf5ef2aSThomas Huth return result; 2442fcf5ef2aSThomas Huth } 2443fcf5ef2aSThomas Huth 2444fcf5ef2aSThomas Huth static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n) 2445fcf5ef2aSThomas Huth { 2446fcf5ef2aSThomas Huth if (n & 1) { 2447fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F; 2448fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= (digit << 4); 2449fcf5ef2aSThomas Huth } else { 2450fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0; 2451fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= digit; 2452fcf5ef2aSThomas Huth } 2453fcf5ef2aSThomas Huth } 2454fcf5ef2aSThomas Huth 2455071663dfSJose Ricardo Ziviani static bool bcd_is_valid(ppc_avr_t *bcd) 2456071663dfSJose Ricardo Ziviani { 2457071663dfSJose Ricardo Ziviani int i; 2458071663dfSJose Ricardo Ziviani int invalid = 0; 2459071663dfSJose Ricardo Ziviani 2460071663dfSJose Ricardo Ziviani if (bcd_get_sgn(bcd) == 0) { 2461071663dfSJose Ricardo Ziviani return false; 2462071663dfSJose Ricardo Ziviani } 2463071663dfSJose Ricardo Ziviani 2464071663dfSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2465071663dfSJose Ricardo Ziviani bcd_get_digit(bcd, i, &invalid); 2466071663dfSJose Ricardo Ziviani if (unlikely(invalid)) { 2467071663dfSJose Ricardo Ziviani return false; 2468071663dfSJose Ricardo Ziviani } 2469071663dfSJose Ricardo Ziviani } 2470071663dfSJose Ricardo Ziviani return true; 2471071663dfSJose Ricardo Ziviani } 2472071663dfSJose Ricardo Ziviani 2473fcf5ef2aSThomas Huth static int bcd_cmp_zero(ppc_avr_t *bcd) 2474fcf5ef2aSThomas Huth { 24753c385a93SMark Cave-Ayland if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) { 2476efa73196SNikunj A Dadhania return CRF_EQ; 2477fcf5ef2aSThomas Huth } else { 2478efa73196SNikunj A Dadhania return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT; 2479fcf5ef2aSThomas Huth } 2480fcf5ef2aSThomas Huth } 2481fcf5ef2aSThomas Huth 2482fcf5ef2aSThomas Huth static uint16_t get_national_digit(ppc_avr_t *reg, int n) 2483fcf5ef2aSThomas Huth { 248460594feaSMark Cave-Ayland return reg->VsrH(7 - n); 2485fcf5ef2aSThomas Huth } 2486fcf5ef2aSThomas Huth 2487fcf5ef2aSThomas Huth static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n) 2488fcf5ef2aSThomas Huth { 248960594feaSMark Cave-Ayland reg->VsrH(7 - n) = val; 2490fcf5ef2aSThomas Huth } 2491fcf5ef2aSThomas Huth 2492fcf5ef2aSThomas Huth static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b) 2493fcf5ef2aSThomas Huth { 2494fcf5ef2aSThomas Huth int i; 2495fcf5ef2aSThomas Huth int invalid = 0; 2496fcf5ef2aSThomas Huth for (i = 31; i > 0; i--) { 2497fcf5ef2aSThomas Huth uint8_t dig_a = bcd_get_digit(a, i, &invalid); 2498fcf5ef2aSThomas Huth uint8_t dig_b = bcd_get_digit(b, i, &invalid); 2499fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2500fcf5ef2aSThomas Huth return 0; /* doesn't matter */ 2501fcf5ef2aSThomas Huth } else if (dig_a > dig_b) { 2502fcf5ef2aSThomas Huth return 1; 2503fcf5ef2aSThomas Huth } else if (dig_a < dig_b) { 2504fcf5ef2aSThomas Huth return -1; 2505fcf5ef2aSThomas Huth } 2506fcf5ef2aSThomas Huth } 2507fcf5ef2aSThomas Huth 2508fcf5ef2aSThomas Huth return 0; 2509fcf5ef2aSThomas Huth } 2510fcf5ef2aSThomas Huth 2511d03b174aSYasmin Beatriz static void bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2512fcf5ef2aSThomas Huth int *overflow) 2513fcf5ef2aSThomas Huth { 2514fcf5ef2aSThomas Huth int carry = 0; 2515fcf5ef2aSThomas Huth int i; 2516fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2517fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) + 2518fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2519fcf5ef2aSThomas Huth if (digit > 9) { 2520fcf5ef2aSThomas Huth carry = 1; 2521fcf5ef2aSThomas Huth digit -= 10; 2522fcf5ef2aSThomas Huth } else { 2523fcf5ef2aSThomas Huth carry = 0; 2524fcf5ef2aSThomas Huth } 2525fcf5ef2aSThomas Huth 2526fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2527fcf5ef2aSThomas Huth } 2528fcf5ef2aSThomas Huth 2529fcf5ef2aSThomas Huth *overflow = carry; 2530fcf5ef2aSThomas Huth } 2531fcf5ef2aSThomas Huth 2532d03b174aSYasmin Beatriz static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2533fcf5ef2aSThomas Huth int *overflow) 2534fcf5ef2aSThomas Huth { 2535fcf5ef2aSThomas Huth int carry = 0; 2536fcf5ef2aSThomas Huth int i; 2537d03b174aSYasmin Beatriz 2538fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2539fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) - 2540fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2541fcf5ef2aSThomas Huth if (digit & 0x80) { 2542fcf5ef2aSThomas Huth carry = -1; 2543fcf5ef2aSThomas Huth digit += 10; 2544fcf5ef2aSThomas Huth } else { 2545fcf5ef2aSThomas Huth carry = 0; 2546fcf5ef2aSThomas Huth } 2547fcf5ef2aSThomas Huth 2548fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2549fcf5ef2aSThomas Huth } 2550fcf5ef2aSThomas Huth 2551fcf5ef2aSThomas Huth *overflow = carry; 2552fcf5ef2aSThomas Huth } 2553fcf5ef2aSThomas Huth 2554fcf5ef2aSThomas Huth uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2555fcf5ef2aSThomas Huth { 2556fcf5ef2aSThomas Huth 2557fcf5ef2aSThomas Huth int sgna = bcd_get_sgn(a); 2558fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2559fcf5ef2aSThomas Huth int invalid = (sgna == 0) || (sgnb == 0); 2560fcf5ef2aSThomas Huth int overflow = 0; 2561fcf5ef2aSThomas Huth uint32_t cr = 0; 2562fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 2563fcf5ef2aSThomas Huth 2564fcf5ef2aSThomas Huth if (!invalid) { 2565fcf5ef2aSThomas Huth if (sgna == sgnb) { 2566fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2567d03b174aSYasmin Beatriz bcd_add_mag(&result, a, b, &invalid, &overflow); 2568d03b174aSYasmin Beatriz cr = bcd_cmp_zero(&result); 2569fcf5ef2aSThomas Huth } else { 2570d03b174aSYasmin Beatriz int magnitude = bcd_cmp_mag(a, b); 2571d03b174aSYasmin Beatriz if (magnitude > 0) { 2572d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2573d03b174aSYasmin Beatriz bcd_sub_mag(&result, a, b, &invalid, &overflow); 2574d03b174aSYasmin Beatriz cr = (sgna > 0) ? CRF_GT : CRF_LT; 2575d03b174aSYasmin Beatriz } else if (magnitude < 0) { 2576fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps); 2577d03b174aSYasmin Beatriz bcd_sub_mag(&result, b, a, &invalid, &overflow); 2578efa73196SNikunj A Dadhania cr = (sgnb > 0) ? CRF_GT : CRF_LT; 2579d03b174aSYasmin Beatriz } else { 2580d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(0, ps); 2581d03b174aSYasmin Beatriz cr = CRF_EQ; 2582d03b174aSYasmin Beatriz } 2583fcf5ef2aSThomas Huth } 2584fcf5ef2aSThomas Huth } 2585fcf5ef2aSThomas Huth 2586fcf5ef2aSThomas Huth if (unlikely(invalid)) { 25873c385a93SMark Cave-Ayland result.VsrD(0) = result.VsrD(1) = -1; 2588efa73196SNikunj A Dadhania cr = CRF_SO; 2589fcf5ef2aSThomas Huth } else if (overflow) { 2590efa73196SNikunj A Dadhania cr |= CRF_SO; 2591fcf5ef2aSThomas Huth } 2592fcf5ef2aSThomas Huth 2593fcf5ef2aSThomas Huth *r = result; 2594fcf5ef2aSThomas Huth 2595fcf5ef2aSThomas Huth return cr; 2596fcf5ef2aSThomas Huth } 2597fcf5ef2aSThomas Huth 2598fcf5ef2aSThomas Huth uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2599fcf5ef2aSThomas Huth { 2600fcf5ef2aSThomas Huth ppc_avr_t bcopy = *b; 2601fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2602fcf5ef2aSThomas Huth if (sgnb < 0) { 2603fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0); 2604fcf5ef2aSThomas Huth } else if (sgnb > 0) { 2605fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_NEG_PREF, 0); 2606fcf5ef2aSThomas Huth } 2607fcf5ef2aSThomas Huth /* else invalid ... defer to bcdadd code for proper handling */ 2608fcf5ef2aSThomas Huth 2609fcf5ef2aSThomas Huth return helper_bcdadd(r, a, &bcopy, ps); 2610fcf5ef2aSThomas Huth } 2611fcf5ef2aSThomas Huth 2612fcf5ef2aSThomas Huth uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2613fcf5ef2aSThomas Huth { 2614fcf5ef2aSThomas Huth int i; 2615fcf5ef2aSThomas Huth int cr = 0; 2616fcf5ef2aSThomas Huth uint16_t national = 0; 2617fcf5ef2aSThomas Huth uint16_t sgnb = get_national_digit(b, 0); 2618fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2619fcf5ef2aSThomas Huth int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG); 2620fcf5ef2aSThomas Huth 2621fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2622fcf5ef2aSThomas Huth national = get_national_digit(b, i); 2623fcf5ef2aSThomas Huth if (unlikely(national < 0x30 || national > 0x39)) { 2624fcf5ef2aSThomas Huth invalid = 1; 2625fcf5ef2aSThomas Huth break; 2626fcf5ef2aSThomas Huth } 2627fcf5ef2aSThomas Huth 2628fcf5ef2aSThomas Huth bcd_put_digit(&ret, national & 0xf, i); 2629fcf5ef2aSThomas Huth } 2630fcf5ef2aSThomas Huth 2631fcf5ef2aSThomas Huth if (sgnb == NATIONAL_PLUS) { 2632fcf5ef2aSThomas Huth bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0); 2633fcf5ef2aSThomas Huth } else { 2634fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2635fcf5ef2aSThomas Huth } 2636fcf5ef2aSThomas Huth 2637fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2638fcf5ef2aSThomas Huth 2639fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2640efa73196SNikunj A Dadhania cr = CRF_SO; 2641fcf5ef2aSThomas Huth } 2642fcf5ef2aSThomas Huth 2643fcf5ef2aSThomas Huth *r = ret; 2644fcf5ef2aSThomas Huth 2645fcf5ef2aSThomas Huth return cr; 2646fcf5ef2aSThomas Huth } 2647fcf5ef2aSThomas Huth 2648fcf5ef2aSThomas Huth uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2649fcf5ef2aSThomas Huth { 2650fcf5ef2aSThomas Huth int i; 2651fcf5ef2aSThomas Huth int cr = 0; 2652fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2653fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2654fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2655fcf5ef2aSThomas Huth 26563c385a93SMark Cave-Ayland int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0); 2657fcf5ef2aSThomas Huth 2658fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2659fcf5ef2aSThomas Huth set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i); 2660fcf5ef2aSThomas Huth 2661fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2662fcf5ef2aSThomas Huth break; 2663fcf5ef2aSThomas Huth } 2664fcf5ef2aSThomas Huth } 2665fcf5ef2aSThomas Huth set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0); 2666fcf5ef2aSThomas Huth 2667fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2668fcf5ef2aSThomas Huth 2669fcf5ef2aSThomas Huth if (ox_flag) { 2670efa73196SNikunj A Dadhania cr |= CRF_SO; 2671fcf5ef2aSThomas Huth } 2672fcf5ef2aSThomas Huth 2673fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2674efa73196SNikunj A Dadhania cr = CRF_SO; 2675fcf5ef2aSThomas Huth } 2676fcf5ef2aSThomas Huth 2677fcf5ef2aSThomas Huth *r = ret; 2678fcf5ef2aSThomas Huth 2679fcf5ef2aSThomas Huth return cr; 2680fcf5ef2aSThomas Huth } 2681fcf5ef2aSThomas Huth 2682fcf5ef2aSThomas Huth uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2683fcf5ef2aSThomas Huth { 2684fcf5ef2aSThomas Huth int i; 2685fcf5ef2aSThomas Huth int cr = 0; 2686fcf5ef2aSThomas Huth int invalid = 0; 2687fcf5ef2aSThomas Huth int zone_digit = 0; 2688fcf5ef2aSThomas Huth int zone_lead = ps ? 0xF : 0x3; 2689fcf5ef2aSThomas Huth int digit = 0; 2690fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2691fcf5ef2aSThomas Huth int sgnb = b->u8[BCD_DIG_BYTE(0)] >> 4; 2692fcf5ef2aSThomas Huth 2693fcf5ef2aSThomas Huth if (unlikely((sgnb < 0xA) && ps)) { 2694fcf5ef2aSThomas Huth invalid = 1; 2695fcf5ef2aSThomas Huth } 2696fcf5ef2aSThomas Huth 2697fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2698365206aeSJose Ricardo Ziviani zone_digit = i ? b->u8[BCD_DIG_BYTE(i * 2)] >> 4 : zone_lead; 2699fcf5ef2aSThomas Huth digit = b->u8[BCD_DIG_BYTE(i * 2)] & 0xF; 2700fcf5ef2aSThomas Huth if (unlikely(zone_digit != zone_lead || digit > 0x9)) { 2701fcf5ef2aSThomas Huth invalid = 1; 2702fcf5ef2aSThomas Huth break; 2703fcf5ef2aSThomas Huth } 2704fcf5ef2aSThomas Huth 2705fcf5ef2aSThomas Huth bcd_put_digit(&ret, digit, i + 1); 2706fcf5ef2aSThomas Huth } 2707fcf5ef2aSThomas Huth 2708fcf5ef2aSThomas Huth if ((ps && (sgnb == 0xB || sgnb == 0xD)) || 2709fcf5ef2aSThomas Huth (!ps && (sgnb & 0x4))) { 2710fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2711fcf5ef2aSThomas Huth } else { 2712fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0); 2713fcf5ef2aSThomas Huth } 2714fcf5ef2aSThomas Huth 2715fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2716fcf5ef2aSThomas Huth 2717fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2718efa73196SNikunj A Dadhania cr = CRF_SO; 2719fcf5ef2aSThomas Huth } 2720fcf5ef2aSThomas Huth 2721fcf5ef2aSThomas Huth *r = ret; 2722fcf5ef2aSThomas Huth 2723fcf5ef2aSThomas Huth return cr; 2724fcf5ef2aSThomas Huth } 2725fcf5ef2aSThomas Huth 2726fcf5ef2aSThomas Huth uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2727fcf5ef2aSThomas Huth { 2728fcf5ef2aSThomas Huth int i; 2729fcf5ef2aSThomas Huth int cr = 0; 2730fcf5ef2aSThomas Huth uint8_t digit = 0; 2731fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2732fcf5ef2aSThomas Huth int zone_lead = (ps) ? 0xF0 : 0x30; 2733fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2734fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2735fcf5ef2aSThomas Huth 27363c385a93SMark Cave-Ayland int ox_flag = ((b->VsrD(0) >> 4) != 0); 2737fcf5ef2aSThomas Huth 2738fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2739fcf5ef2aSThomas Huth digit = bcd_get_digit(b, i + 1, &invalid); 2740fcf5ef2aSThomas Huth 2741fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2742fcf5ef2aSThomas Huth break; 2743fcf5ef2aSThomas Huth } 2744fcf5ef2aSThomas Huth 2745fcf5ef2aSThomas Huth ret.u8[BCD_DIG_BYTE(i * 2)] = zone_lead + digit; 2746fcf5ef2aSThomas Huth } 2747fcf5ef2aSThomas Huth 2748fcf5ef2aSThomas Huth if (ps) { 2749fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1); 2750fcf5ef2aSThomas Huth } else { 2751fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1); 2752fcf5ef2aSThomas Huth } 2753fcf5ef2aSThomas Huth 2754fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2755fcf5ef2aSThomas Huth 2756fcf5ef2aSThomas Huth if (ox_flag) { 2757efa73196SNikunj A Dadhania cr |= CRF_SO; 2758fcf5ef2aSThomas Huth } 2759fcf5ef2aSThomas Huth 2760fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2761efa73196SNikunj A Dadhania cr = CRF_SO; 2762fcf5ef2aSThomas Huth } 2763fcf5ef2aSThomas Huth 2764fcf5ef2aSThomas Huth *r = ret; 2765fcf5ef2aSThomas Huth 2766fcf5ef2aSThomas Huth return cr; 2767fcf5ef2aSThomas Huth } 2768fcf5ef2aSThomas Huth 2769a406c058SJose Ricardo Ziviani uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2770a406c058SJose Ricardo Ziviani { 2771a406c058SJose Ricardo Ziviani int i; 2772a406c058SJose Ricardo Ziviani int cr = 0; 2773a406c058SJose Ricardo Ziviani uint64_t lo_value; 2774a406c058SJose Ricardo Ziviani uint64_t hi_value; 2775a406c058SJose Ricardo Ziviani ppc_avr_t ret = { .u64 = { 0, 0 } }; 2776a406c058SJose Ricardo Ziviani 27773c385a93SMark Cave-Ayland if (b->VsrSD(0) < 0) { 27783c385a93SMark Cave-Ayland lo_value = -b->VsrSD(1); 27793c385a93SMark Cave-Ayland hi_value = ~b->VsrD(0) + !lo_value; 2780a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, 0xD, 0); 2781a406c058SJose Ricardo Ziviani } else { 27823c385a93SMark Cave-Ayland lo_value = b->VsrD(1); 27833c385a93SMark Cave-Ayland hi_value = b->VsrD(0); 2784a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0); 2785a406c058SJose Ricardo Ziviani } 2786a406c058SJose Ricardo Ziviani 2787a406c058SJose Ricardo Ziviani if (divu128(&lo_value, &hi_value, 1000000000000000ULL) || 2788a406c058SJose Ricardo Ziviani lo_value > 9999999999999999ULL) { 2789a406c058SJose Ricardo Ziviani cr = CRF_SO; 2790a406c058SJose Ricardo Ziviani } 2791a406c058SJose Ricardo Ziviani 2792a406c058SJose Ricardo Ziviani for (i = 1; i < 16; hi_value /= 10, i++) { 2793a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, hi_value % 10, i); 2794a406c058SJose Ricardo Ziviani } 2795a406c058SJose Ricardo Ziviani 2796a406c058SJose Ricardo Ziviani for (; i < 32; lo_value /= 10, i++) { 2797a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, lo_value % 10, i); 2798a406c058SJose Ricardo Ziviani } 2799a406c058SJose Ricardo Ziviani 2800a406c058SJose Ricardo Ziviani cr |= bcd_cmp_zero(&ret); 2801a406c058SJose Ricardo Ziviani 2802a406c058SJose Ricardo Ziviani *r = ret; 2803a406c058SJose Ricardo Ziviani 2804a406c058SJose Ricardo Ziviani return cr; 2805a406c058SJose Ricardo Ziviani } 2806a406c058SJose Ricardo Ziviani 2807c85bc7ddSJose Ricardo Ziviani uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2808c85bc7ddSJose Ricardo Ziviani { 2809c85bc7ddSJose Ricardo Ziviani uint8_t i; 2810c85bc7ddSJose Ricardo Ziviani int cr; 2811c85bc7ddSJose Ricardo Ziviani uint64_t carry; 2812c85bc7ddSJose Ricardo Ziviani uint64_t unused; 2813c85bc7ddSJose Ricardo Ziviani uint64_t lo_value; 2814c85bc7ddSJose Ricardo Ziviani uint64_t hi_value = 0; 2815c85bc7ddSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2816c85bc7ddSJose Ricardo Ziviani int invalid = (sgnb == 0); 2817c85bc7ddSJose Ricardo Ziviani 2818c85bc7ddSJose Ricardo Ziviani lo_value = bcd_get_digit(b, 31, &invalid); 2819c85bc7ddSJose Ricardo Ziviani for (i = 30; i > 0; i--) { 2820c85bc7ddSJose Ricardo Ziviani mulu64(&lo_value, &carry, lo_value, 10ULL); 2821c85bc7ddSJose Ricardo Ziviani mulu64(&hi_value, &unused, hi_value, 10ULL); 2822c85bc7ddSJose Ricardo Ziviani lo_value += bcd_get_digit(b, i, &invalid); 2823c85bc7ddSJose Ricardo Ziviani hi_value += carry; 2824c85bc7ddSJose Ricardo Ziviani 2825c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2826c85bc7ddSJose Ricardo Ziviani break; 2827c85bc7ddSJose Ricardo Ziviani } 2828c85bc7ddSJose Ricardo Ziviani } 2829c85bc7ddSJose Ricardo Ziviani 2830c85bc7ddSJose Ricardo Ziviani if (sgnb == -1) { 28313c385a93SMark Cave-Ayland r->VsrSD(1) = -lo_value; 28323c385a93SMark Cave-Ayland r->VsrSD(0) = ~hi_value + !r->VsrSD(1); 2833c85bc7ddSJose Ricardo Ziviani } else { 28343c385a93SMark Cave-Ayland r->VsrSD(1) = lo_value; 28353c385a93SMark Cave-Ayland r->VsrSD(0) = hi_value; 2836c85bc7ddSJose Ricardo Ziviani } 2837c85bc7ddSJose Ricardo Ziviani 2838c85bc7ddSJose Ricardo Ziviani cr = bcd_cmp_zero(b); 2839c85bc7ddSJose Ricardo Ziviani 2840c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2841c85bc7ddSJose Ricardo Ziviani cr = CRF_SO; 2842c85bc7ddSJose Ricardo Ziviani } 2843c85bc7ddSJose Ricardo Ziviani 2844c85bc7ddSJose Ricardo Ziviani return cr; 2845c85bc7ddSJose Ricardo Ziviani } 2846c85bc7ddSJose Ricardo Ziviani 2847c3025c3bSJose Ricardo Ziviani uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2848c3025c3bSJose Ricardo Ziviani { 2849c3025c3bSJose Ricardo Ziviani int i; 2850c3025c3bSJose Ricardo Ziviani int invalid = 0; 2851c3025c3bSJose Ricardo Ziviani 2852c3025c3bSJose Ricardo Ziviani if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) { 2853c3025c3bSJose Ricardo Ziviani return CRF_SO; 2854c3025c3bSJose Ricardo Ziviani } 2855c3025c3bSJose Ricardo Ziviani 2856c3025c3bSJose Ricardo Ziviani *r = *a; 2857c3025c3bSJose Ricardo Ziviani bcd_put_digit(r, b->u8[BCD_DIG_BYTE(0)] & 0xF, 0); 2858c3025c3bSJose Ricardo Ziviani 2859c3025c3bSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2860c3025c3bSJose Ricardo Ziviani bcd_get_digit(a, i, &invalid); 2861c3025c3bSJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2862c3025c3bSJose Ricardo Ziviani if (unlikely(invalid)) { 2863c3025c3bSJose Ricardo Ziviani return CRF_SO; 2864c3025c3bSJose Ricardo Ziviani } 2865c3025c3bSJose Ricardo Ziviani } 2866c3025c3bSJose Ricardo Ziviani 2867c3025c3bSJose Ricardo Ziviani return bcd_cmp_zero(r); 2868c3025c3bSJose Ricardo Ziviani } 2869c3025c3bSJose Ricardo Ziviani 2870466a3f9cSJose Ricardo Ziviani uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2871466a3f9cSJose Ricardo Ziviani { 2872466a3f9cSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2873466a3f9cSJose Ricardo Ziviani 2874466a3f9cSJose Ricardo Ziviani *r = *b; 2875466a3f9cSJose Ricardo Ziviani bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0); 2876466a3f9cSJose Ricardo Ziviani 2877071663dfSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2878466a3f9cSJose Ricardo Ziviani return CRF_SO; 2879466a3f9cSJose Ricardo Ziviani } 2880466a3f9cSJose Ricardo Ziviani 2881466a3f9cSJose Ricardo Ziviani return bcd_cmp_zero(r); 2882466a3f9cSJose Ricardo Ziviani } 2883466a3f9cSJose Ricardo Ziviani 2884e04797f7SJose Ricardo Ziviani uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2885e04797f7SJose Ricardo Ziviani { 2886e04797f7SJose Ricardo Ziviani int cr; 2887e04797f7SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 2888e04797f7SJose Ricardo Ziviani int i = a->s8[7]; 2889e04797f7SJose Ricardo Ziviani #else 2890e04797f7SJose Ricardo Ziviani int i = a->s8[8]; 2891e04797f7SJose Ricardo Ziviani #endif 2892e04797f7SJose Ricardo Ziviani bool ox_flag = false; 2893e04797f7SJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2894e04797f7SJose Ricardo Ziviani ppc_avr_t ret = *b; 28953c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2896e04797f7SJose Ricardo Ziviani 2897e04797f7SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2898e04797f7SJose Ricardo Ziviani return CRF_SO; 2899e04797f7SJose Ricardo Ziviani } 2900e04797f7SJose Ricardo Ziviani 2901e04797f7SJose Ricardo Ziviani if (unlikely(i > 31)) { 2902e04797f7SJose Ricardo Ziviani i = 31; 2903e04797f7SJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2904e04797f7SJose Ricardo Ziviani i = -31; 2905e04797f7SJose Ricardo Ziviani } 2906e04797f7SJose Ricardo Ziviani 2907e04797f7SJose Ricardo Ziviani if (i > 0) { 29083c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2909e04797f7SJose Ricardo Ziviani } else { 29103c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2911e04797f7SJose Ricardo Ziviani } 2912e04797f7SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2913e04797f7SJose Ricardo Ziviani 2914e04797f7SJose Ricardo Ziviani *r = ret; 2915e04797f7SJose Ricardo Ziviani 2916e04797f7SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2917e04797f7SJose Ricardo Ziviani if (ox_flag) { 2918e04797f7SJose Ricardo Ziviani cr |= CRF_SO; 2919e04797f7SJose Ricardo Ziviani } 2920e04797f7SJose Ricardo Ziviani 2921e04797f7SJose Ricardo Ziviani return cr; 2922e04797f7SJose Ricardo Ziviani } 2923e04797f7SJose Ricardo Ziviani 2924a49a95e9SJose Ricardo Ziviani uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2925a49a95e9SJose Ricardo Ziviani { 2926a49a95e9SJose Ricardo Ziviani int cr; 2927a49a95e9SJose Ricardo Ziviani int i; 2928a49a95e9SJose Ricardo Ziviani int invalid = 0; 2929a49a95e9SJose Ricardo Ziviani bool ox_flag = false; 2930a49a95e9SJose Ricardo Ziviani ppc_avr_t ret = *b; 2931a49a95e9SJose Ricardo Ziviani 2932a49a95e9SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 2933a49a95e9SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2934a49a95e9SJose Ricardo Ziviani 2935a49a95e9SJose Ricardo Ziviani if (unlikely(invalid)) { 2936a49a95e9SJose Ricardo Ziviani return CRF_SO; 2937a49a95e9SJose Ricardo Ziviani } 2938a49a95e9SJose Ricardo Ziviani } 2939a49a95e9SJose Ricardo Ziviani 2940a49a95e9SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 2941a49a95e9SJose Ricardo Ziviani i = a->s8[7]; 2942a49a95e9SJose Ricardo Ziviani #else 2943a49a95e9SJose Ricardo Ziviani i = a->s8[8]; 2944a49a95e9SJose Ricardo Ziviani #endif 2945a49a95e9SJose Ricardo Ziviani if (i >= 32) { 2946a49a95e9SJose Ricardo Ziviani ox_flag = true; 29473c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2948a49a95e9SJose Ricardo Ziviani } else if (i <= -32) { 29493c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2950a49a95e9SJose Ricardo Ziviani } else if (i > 0) { 29513c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2952a49a95e9SJose Ricardo Ziviani } else { 29533c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2954a49a95e9SJose Ricardo Ziviani } 2955a49a95e9SJose Ricardo Ziviani *r = ret; 2956a49a95e9SJose Ricardo Ziviani 2957a49a95e9SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2958a49a95e9SJose Ricardo Ziviani if (ox_flag) { 2959a49a95e9SJose Ricardo Ziviani cr |= CRF_SO; 2960a49a95e9SJose Ricardo Ziviani } 2961a49a95e9SJose Ricardo Ziviani 2962a49a95e9SJose Ricardo Ziviani return cr; 2963a49a95e9SJose Ricardo Ziviani } 2964a49a95e9SJose Ricardo Ziviani 2965a54238adSJose Ricardo Ziviani uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2966a54238adSJose Ricardo Ziviani { 2967a54238adSJose Ricardo Ziviani int cr; 2968a54238adSJose Ricardo Ziviani int unused = 0; 2969a54238adSJose Ricardo Ziviani int invalid = 0; 2970a54238adSJose Ricardo Ziviani bool ox_flag = false; 2971a54238adSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2972a54238adSJose Ricardo Ziviani ppc_avr_t ret = *b; 29733c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2974a54238adSJose Ricardo Ziviani 2975a54238adSJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 2976a54238adSJose Ricardo Ziviani int i = a->s8[7]; 2977a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0, 0x10 } }; 2978a54238adSJose Ricardo Ziviani #else 2979a54238adSJose Ricardo Ziviani int i = a->s8[8]; 2980a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0x10, 0 } }; 2981a54238adSJose Ricardo Ziviani #endif 2982a54238adSJose Ricardo Ziviani 2983a54238adSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2984a54238adSJose Ricardo Ziviani return CRF_SO; 2985a54238adSJose Ricardo Ziviani } 2986a54238adSJose Ricardo Ziviani 2987a54238adSJose Ricardo Ziviani if (unlikely(i > 31)) { 2988a54238adSJose Ricardo Ziviani i = 31; 2989a54238adSJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2990a54238adSJose Ricardo Ziviani i = -31; 2991a54238adSJose Ricardo Ziviani } 2992a54238adSJose Ricardo Ziviani 2993a54238adSJose Ricardo Ziviani if (i > 0) { 29943c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2995a54238adSJose Ricardo Ziviani } else { 29963c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2997a54238adSJose Ricardo Ziviani 2998a54238adSJose Ricardo Ziviani if (bcd_get_digit(&ret, 0, &invalid) >= 5) { 2999a54238adSJose Ricardo Ziviani bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused); 3000a54238adSJose Ricardo Ziviani } 3001a54238adSJose Ricardo Ziviani } 3002a54238adSJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 3003a54238adSJose Ricardo Ziviani 3004a54238adSJose Ricardo Ziviani cr = bcd_cmp_zero(&ret); 3005a54238adSJose Ricardo Ziviani if (ox_flag) { 3006a54238adSJose Ricardo Ziviani cr |= CRF_SO; 3007a54238adSJose Ricardo Ziviani } 3008a54238adSJose Ricardo Ziviani *r = ret; 3009a54238adSJose Ricardo Ziviani 3010a54238adSJose Ricardo Ziviani return cr; 3011a54238adSJose Ricardo Ziviani } 3012a54238adSJose Ricardo Ziviani 301331bc4d11SJose Ricardo Ziviani uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 301431bc4d11SJose Ricardo Ziviani { 301531bc4d11SJose Ricardo Ziviani uint64_t mask; 301631bc4d11SJose Ricardo Ziviani uint32_t ox_flag = 0; 301731bc4d11SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 301831bc4d11SJose Ricardo Ziviani int i = a->s16[3] + 1; 301931bc4d11SJose Ricardo Ziviani #else 302031bc4d11SJose Ricardo Ziviani int i = a->s16[4] + 1; 302131bc4d11SJose Ricardo Ziviani #endif 302231bc4d11SJose Ricardo Ziviani ppc_avr_t ret = *b; 302331bc4d11SJose Ricardo Ziviani 302431bc4d11SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 302531bc4d11SJose Ricardo Ziviani return CRF_SO; 302631bc4d11SJose Ricardo Ziviani } 302731bc4d11SJose Ricardo Ziviani 302831bc4d11SJose Ricardo Ziviani if (i > 16 && i < 32) { 302931bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 30303c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 303131bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 303231bc4d11SJose Ricardo Ziviani } 303331bc4d11SJose Ricardo Ziviani 30343c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 303531bc4d11SJose Ricardo Ziviani } else if (i >= 0 && i <= 16) { 303631bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 30373c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 303831bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 303931bc4d11SJose Ricardo Ziviani } 304031bc4d11SJose Ricardo Ziviani 30413c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 30423c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 304331bc4d11SJose Ricardo Ziviani } 304431bc4d11SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0); 304531bc4d11SJose Ricardo Ziviani *r = ret; 304631bc4d11SJose Ricardo Ziviani 304731bc4d11SJose Ricardo Ziviani return bcd_cmp_zero(&ret) | ox_flag; 304831bc4d11SJose Ricardo Ziviani } 304931bc4d11SJose Ricardo Ziviani 30505c32e2e4SJose Ricardo Ziviani uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 30515c32e2e4SJose Ricardo Ziviani { 30525c32e2e4SJose Ricardo Ziviani int i; 30535c32e2e4SJose Ricardo Ziviani uint64_t mask; 30545c32e2e4SJose Ricardo Ziviani uint32_t ox_flag = 0; 30555c32e2e4SJose Ricardo Ziviani int invalid = 0; 30565c32e2e4SJose Ricardo Ziviani ppc_avr_t ret = *b; 30575c32e2e4SJose Ricardo Ziviani 30585c32e2e4SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 30595c32e2e4SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 30605c32e2e4SJose Ricardo Ziviani 30615c32e2e4SJose Ricardo Ziviani if (unlikely(invalid)) { 30625c32e2e4SJose Ricardo Ziviani return CRF_SO; 30635c32e2e4SJose Ricardo Ziviani } 30645c32e2e4SJose Ricardo Ziviani } 30655c32e2e4SJose Ricardo Ziviani 30665c32e2e4SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 30675c32e2e4SJose Ricardo Ziviani i = a->s16[3]; 30685c32e2e4SJose Ricardo Ziviani #else 30695c32e2e4SJose Ricardo Ziviani i = a->s16[4]; 30705c32e2e4SJose Ricardo Ziviani #endif 30715c32e2e4SJose Ricardo Ziviani if (i > 16 && i < 33) { 30725c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 30733c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 30745c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 30755c32e2e4SJose Ricardo Ziviani } 30765c32e2e4SJose Ricardo Ziviani 30773c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 30785c32e2e4SJose Ricardo Ziviani } else if (i > 0 && i <= 16) { 30795c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 30803c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 30815c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 30825c32e2e4SJose Ricardo Ziviani } 30835c32e2e4SJose Ricardo Ziviani 30843c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 30853c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 30865c32e2e4SJose Ricardo Ziviani } else if (i == 0) { 30873c385a93SMark Cave-Ayland if (ret.VsrD(0) || ret.VsrD(1)) { 30885c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 30895c32e2e4SJose Ricardo Ziviani } 30903c385a93SMark Cave-Ayland ret.VsrD(0) = ret.VsrD(1) = 0; 30915c32e2e4SJose Ricardo Ziviani } 30925c32e2e4SJose Ricardo Ziviani 30935c32e2e4SJose Ricardo Ziviani *r = ret; 30943c385a93SMark Cave-Ayland if (r->VsrD(0) == 0 && r->VsrD(1) == 0) { 30955c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_EQ; 30965c32e2e4SJose Ricardo Ziviani } 30975c32e2e4SJose Ricardo Ziviani 30985c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_GT; 30995c32e2e4SJose Ricardo Ziviani } 31005c32e2e4SJose Ricardo Ziviani 3101fcf5ef2aSThomas Huth void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a) 3102fcf5ef2aSThomas Huth { 3103fcf5ef2aSThomas Huth int i; 3104fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3105fcf5ef2aSThomas Huth r->u8[i] = AES_sbox[a->u8[i]]; 3106fcf5ef2aSThomas Huth } 3107fcf5ef2aSThomas Huth } 3108fcf5ef2aSThomas Huth 3109fcf5ef2aSThomas Huth void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3110fcf5ef2aSThomas Huth { 3111fcf5ef2aSThomas Huth ppc_avr_t result; 3112fcf5ef2aSThomas Huth int i; 3113fcf5ef2aSThomas Huth 3114fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 31152dea57dbSMark Cave-Ayland result.VsrW(i) = b->VsrW(i) ^ 31162dea57dbSMark Cave-Ayland (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^ 31172dea57dbSMark Cave-Ayland AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^ 31182dea57dbSMark Cave-Ayland AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^ 31192dea57dbSMark Cave-Ayland AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]); 3120fcf5ef2aSThomas Huth } 3121fcf5ef2aSThomas Huth *r = result; 3122fcf5ef2aSThomas Huth } 3123fcf5ef2aSThomas Huth 3124fcf5ef2aSThomas Huth void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3125fcf5ef2aSThomas Huth { 3126fcf5ef2aSThomas Huth ppc_avr_t result; 3127fcf5ef2aSThomas Huth int i; 3128fcf5ef2aSThomas Huth 3129fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 31302dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]); 3131fcf5ef2aSThomas Huth } 3132fcf5ef2aSThomas Huth *r = result; 3133fcf5ef2aSThomas Huth } 3134fcf5ef2aSThomas Huth 3135fcf5ef2aSThomas Huth void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3136fcf5ef2aSThomas Huth { 3137fcf5ef2aSThomas Huth /* This differs from what is written in ISA V2.07. The RTL is */ 3138fcf5ef2aSThomas Huth /* incorrect and will be fixed in V2.07B. */ 3139fcf5ef2aSThomas Huth int i; 3140fcf5ef2aSThomas Huth ppc_avr_t tmp; 3141fcf5ef2aSThomas Huth 3142fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 31432dea57dbSMark Cave-Ayland tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])]; 3144fcf5ef2aSThomas Huth } 3145fcf5ef2aSThomas Huth 3146fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 31472dea57dbSMark Cave-Ayland r->VsrW(i) = 31482dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 0)][0] ^ 31492dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 1)][1] ^ 31502dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 2)][2] ^ 31512dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 3)][3]; 3152fcf5ef2aSThomas Huth } 3153fcf5ef2aSThomas Huth } 3154fcf5ef2aSThomas Huth 3155fcf5ef2aSThomas Huth void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3156fcf5ef2aSThomas Huth { 3157fcf5ef2aSThomas Huth ppc_avr_t result; 3158fcf5ef2aSThomas Huth int i; 3159fcf5ef2aSThomas Huth 3160fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 31612dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]); 3162fcf5ef2aSThomas Huth } 3163fcf5ef2aSThomas Huth *r = result; 3164fcf5ef2aSThomas Huth } 3165fcf5ef2aSThomas Huth 3166fcf5ef2aSThomas Huth void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3167fcf5ef2aSThomas Huth { 3168fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3169fcf5ef2aSThomas Huth int six = st_six & 0xF; 3170fcf5ef2aSThomas Huth int i; 3171fcf5ef2aSThomas Huth 3172730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 3173fcf5ef2aSThomas Huth if (st == 0) { 3174fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 31750ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 7) ^ 31760ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 18) ^ 3177730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 3); 3178fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 31790ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 17) ^ 31800ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 19) ^ 3181730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 10); 3182fcf5ef2aSThomas Huth } 3183fcf5ef2aSThomas Huth } else { /* st == 1 */ 3184fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 31850ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 2) ^ 31860ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 13) ^ 31870ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 22); 3188fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 31890ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 6) ^ 31900ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 11) ^ 31910ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 25); 3192fcf5ef2aSThomas Huth } 3193fcf5ef2aSThomas Huth } 3194fcf5ef2aSThomas Huth } 3195fcf5ef2aSThomas Huth } 3196fcf5ef2aSThomas Huth 3197fcf5ef2aSThomas Huth void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3198fcf5ef2aSThomas Huth { 3199fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3200fcf5ef2aSThomas Huth int six = st_six & 0xF; 3201fcf5ef2aSThomas Huth int i; 3202fcf5ef2aSThomas Huth 3203730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 3204fcf5ef2aSThomas Huth if (st == 0) { 3205fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 32060ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 1) ^ 32070ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 8) ^ 3208730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 7); 3209fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 32100ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 19) ^ 32110ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 61) ^ 3212730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 6); 3213fcf5ef2aSThomas Huth } 3214fcf5ef2aSThomas Huth } else { /* st == 1 */ 3215fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 32160ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 28) ^ 32170ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 34) ^ 32180ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 39); 3219fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 32200ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 14) ^ 32210ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 18) ^ 32220ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 41); 3223fcf5ef2aSThomas Huth } 3224fcf5ef2aSThomas Huth } 3225fcf5ef2aSThomas Huth } 3226fcf5ef2aSThomas Huth } 3227fcf5ef2aSThomas Huth 3228fcf5ef2aSThomas Huth void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 3229fcf5ef2aSThomas Huth { 3230fcf5ef2aSThomas Huth ppc_avr_t result; 3231fcf5ef2aSThomas Huth int i; 3232fcf5ef2aSThomas Huth 323360594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 323460594feaSMark Cave-Ayland int indexA = c->VsrB(i) >> 4; 323560594feaSMark Cave-Ayland int indexB = c->VsrB(i) & 0xF; 323660594feaSMark Cave-Ayland 323760594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB); 3238fcf5ef2aSThomas Huth } 3239fcf5ef2aSThomas Huth *r = result; 3240fcf5ef2aSThomas Huth } 3241fcf5ef2aSThomas Huth 3242fcf5ef2aSThomas Huth #undef VECTOR_FOR_INORDER_I 3243fcf5ef2aSThomas Huth 3244fcf5ef2aSThomas Huth /*****************************************************************************/ 3245fcf5ef2aSThomas Huth /* SPE extension helpers */ 3246fcf5ef2aSThomas Huth /* Use a table to make this quicker */ 3247fcf5ef2aSThomas Huth static const uint8_t hbrev[16] = { 3248fcf5ef2aSThomas Huth 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 3249fcf5ef2aSThomas Huth 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, 3250fcf5ef2aSThomas Huth }; 3251fcf5ef2aSThomas Huth 3252fcf5ef2aSThomas Huth static inline uint8_t byte_reverse(uint8_t val) 3253fcf5ef2aSThomas Huth { 3254fcf5ef2aSThomas Huth return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); 3255fcf5ef2aSThomas Huth } 3256fcf5ef2aSThomas Huth 3257fcf5ef2aSThomas Huth static inline uint32_t word_reverse(uint32_t val) 3258fcf5ef2aSThomas Huth { 3259fcf5ef2aSThomas Huth return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | 3260fcf5ef2aSThomas Huth (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); 3261fcf5ef2aSThomas Huth } 3262fcf5ef2aSThomas Huth 3263fcf5ef2aSThomas Huth #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */ 3264fcf5ef2aSThomas Huth target_ulong helper_brinc(target_ulong arg1, target_ulong arg2) 3265fcf5ef2aSThomas Huth { 3266fcf5ef2aSThomas Huth uint32_t a, b, d, mask; 3267fcf5ef2aSThomas Huth 3268fcf5ef2aSThomas Huth mask = UINT32_MAX >> (32 - MASKBITS); 3269fcf5ef2aSThomas Huth a = arg1 & mask; 3270fcf5ef2aSThomas Huth b = arg2 & mask; 3271fcf5ef2aSThomas Huth d = word_reverse(1 + word_reverse(a | ~b)); 3272fcf5ef2aSThomas Huth return (arg1 & ~mask) | (d & b); 3273fcf5ef2aSThomas Huth } 3274fcf5ef2aSThomas Huth 3275fcf5ef2aSThomas Huth uint32_t helper_cntlsw32(uint32_t val) 3276fcf5ef2aSThomas Huth { 3277fcf5ef2aSThomas Huth if (val & 0x80000000) { 3278fcf5ef2aSThomas Huth return clz32(~val); 3279fcf5ef2aSThomas Huth } else { 3280fcf5ef2aSThomas Huth return clz32(val); 3281fcf5ef2aSThomas Huth } 3282fcf5ef2aSThomas Huth } 3283fcf5ef2aSThomas Huth 3284fcf5ef2aSThomas Huth uint32_t helper_cntlzw32(uint32_t val) 3285fcf5ef2aSThomas Huth { 3286fcf5ef2aSThomas Huth return clz32(val); 3287fcf5ef2aSThomas Huth } 3288fcf5ef2aSThomas Huth 3289fcf5ef2aSThomas Huth /* 440 specific */ 3290fcf5ef2aSThomas Huth target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high, 3291fcf5ef2aSThomas Huth target_ulong low, uint32_t update_Rc) 3292fcf5ef2aSThomas Huth { 3293fcf5ef2aSThomas Huth target_ulong mask; 3294fcf5ef2aSThomas Huth int i; 3295fcf5ef2aSThomas Huth 3296fcf5ef2aSThomas Huth i = 1; 3297fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3298fcf5ef2aSThomas Huth if ((high & mask) == 0) { 3299fcf5ef2aSThomas Huth if (update_Rc) { 3300fcf5ef2aSThomas Huth env->crf[0] = 0x4; 3301fcf5ef2aSThomas Huth } 3302fcf5ef2aSThomas Huth goto done; 3303fcf5ef2aSThomas Huth } 3304fcf5ef2aSThomas Huth i++; 3305fcf5ef2aSThomas Huth } 3306fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3307fcf5ef2aSThomas Huth if ((low & mask) == 0) { 3308fcf5ef2aSThomas Huth if (update_Rc) { 3309fcf5ef2aSThomas Huth env->crf[0] = 0x8; 3310fcf5ef2aSThomas Huth } 3311fcf5ef2aSThomas Huth goto done; 3312fcf5ef2aSThomas Huth } 3313fcf5ef2aSThomas Huth i++; 3314fcf5ef2aSThomas Huth } 3315fcf5ef2aSThomas Huth i = 8; 3316fcf5ef2aSThomas Huth if (update_Rc) { 3317fcf5ef2aSThomas Huth env->crf[0] = 0x2; 3318fcf5ef2aSThomas Huth } 3319fcf5ef2aSThomas Huth done: 3320fcf5ef2aSThomas Huth env->xer = (env->xer & ~0x7F) | i; 3321fcf5ef2aSThomas Huth if (update_Rc) { 3322fcf5ef2aSThomas Huth env->crf[0] |= xer_so; 3323fcf5ef2aSThomas Huth } 3324fcf5ef2aSThomas Huth return i; 3325fcf5ef2aSThomas Huth } 3326