1fcf5ef2aSThomas Huth /* 2fcf5ef2aSThomas Huth * PowerPC integer and vector emulation helpers for QEMU. 3fcf5ef2aSThomas Huth * 4fcf5ef2aSThomas Huth * Copyright (c) 2003-2007 Jocelyn Mayer 5fcf5ef2aSThomas Huth * 6fcf5ef2aSThomas Huth * This library is free software; you can redistribute it and/or 7fcf5ef2aSThomas Huth * modify it under the terms of the GNU Lesser General Public 8fcf5ef2aSThomas Huth * License as published by the Free Software Foundation; either 9fcf5ef2aSThomas Huth * version 2 of the License, or (at your option) any later version. 10fcf5ef2aSThomas Huth * 11fcf5ef2aSThomas Huth * This library is distributed in the hope that it will be useful, 12fcf5ef2aSThomas Huth * but WITHOUT ANY WARRANTY; without even the implied warranty of 13fcf5ef2aSThomas Huth * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14fcf5ef2aSThomas Huth * Lesser General Public License for more details. 15fcf5ef2aSThomas Huth * 16fcf5ef2aSThomas Huth * You should have received a copy of the GNU Lesser General Public 17fcf5ef2aSThomas Huth * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18fcf5ef2aSThomas Huth */ 19fcf5ef2aSThomas Huth #include "qemu/osdep.h" 20fcf5ef2aSThomas Huth #include "cpu.h" 21fcf5ef2aSThomas Huth #include "internal.h" 22fcf5ef2aSThomas Huth #include "qemu/host-utils.h" 23fcf5ef2aSThomas Huth #include "exec/helper-proto.h" 24fcf5ef2aSThomas Huth #include "crypto/aes.h" 2524f91e81SAlex Bennée #include "fpu/softfloat.h" 26fcf5ef2aSThomas Huth 27fcf5ef2aSThomas Huth #include "helper_regs.h" 28fcf5ef2aSThomas Huth /*****************************************************************************/ 29fcf5ef2aSThomas Huth /* Fixed point operations helpers */ 30fcf5ef2aSThomas Huth 31f32899deSNikunj A Dadhania static inline void helper_update_ov_legacy(CPUPPCState *env, int ov) 32f32899deSNikunj A Dadhania { 33f32899deSNikunj A Dadhania if (unlikely(ov)) { 34f32899deSNikunj A Dadhania env->so = env->ov = 1; 35f32899deSNikunj A Dadhania } else { 36f32899deSNikunj A Dadhania env->ov = 0; 37f32899deSNikunj A Dadhania } 38f32899deSNikunj A Dadhania } 39f32899deSNikunj A Dadhania 40fcf5ef2aSThomas Huth target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb, 41fcf5ef2aSThomas Huth uint32_t oe) 42fcf5ef2aSThomas Huth { 43fcf5ef2aSThomas Huth uint64_t rt = 0; 44fcf5ef2aSThomas Huth int overflow = 0; 45fcf5ef2aSThomas Huth 46fcf5ef2aSThomas Huth uint64_t dividend = (uint64_t)ra << 32; 47fcf5ef2aSThomas Huth uint64_t divisor = (uint32_t)rb; 48fcf5ef2aSThomas Huth 49fcf5ef2aSThomas Huth if (unlikely(divisor == 0)) { 50fcf5ef2aSThomas Huth overflow = 1; 51fcf5ef2aSThomas Huth } else { 52fcf5ef2aSThomas Huth rt = dividend / divisor; 53fcf5ef2aSThomas Huth overflow = rt > UINT32_MAX; 54fcf5ef2aSThomas Huth } 55fcf5ef2aSThomas Huth 56fcf5ef2aSThomas Huth if (unlikely(overflow)) { 57fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 58fcf5ef2aSThomas Huth } 59fcf5ef2aSThomas Huth 60fcf5ef2aSThomas Huth if (oe) { 61f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 62fcf5ef2aSThomas Huth } 63fcf5ef2aSThomas Huth 64fcf5ef2aSThomas Huth return (target_ulong)rt; 65fcf5ef2aSThomas Huth } 66fcf5ef2aSThomas Huth 67fcf5ef2aSThomas Huth target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb, 68fcf5ef2aSThomas Huth uint32_t oe) 69fcf5ef2aSThomas Huth { 70fcf5ef2aSThomas Huth int64_t rt = 0; 71fcf5ef2aSThomas Huth int overflow = 0; 72fcf5ef2aSThomas Huth 73fcf5ef2aSThomas Huth int64_t dividend = (int64_t)ra << 32; 74fcf5ef2aSThomas Huth int64_t divisor = (int64_t)((int32_t)rb); 75fcf5ef2aSThomas Huth 76fcf5ef2aSThomas Huth if (unlikely((divisor == 0) || 77fcf5ef2aSThomas Huth ((divisor == -1ull) && (dividend == INT64_MIN)))) { 78fcf5ef2aSThomas Huth overflow = 1; 79fcf5ef2aSThomas Huth } else { 80fcf5ef2aSThomas Huth rt = dividend / divisor; 81fcf5ef2aSThomas Huth overflow = rt != (int32_t)rt; 82fcf5ef2aSThomas Huth } 83fcf5ef2aSThomas Huth 84fcf5ef2aSThomas Huth if (unlikely(overflow)) { 85fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 86fcf5ef2aSThomas Huth } 87fcf5ef2aSThomas Huth 88fcf5ef2aSThomas Huth if (oe) { 89f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 90fcf5ef2aSThomas Huth } 91fcf5ef2aSThomas Huth 92fcf5ef2aSThomas Huth return (target_ulong)rt; 93fcf5ef2aSThomas Huth } 94fcf5ef2aSThomas Huth 95fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 96fcf5ef2aSThomas Huth 97fcf5ef2aSThomas Huth uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe) 98fcf5ef2aSThomas Huth { 99fcf5ef2aSThomas Huth uint64_t rt = 0; 100fcf5ef2aSThomas Huth int overflow = 0; 101fcf5ef2aSThomas Huth 102fcf5ef2aSThomas Huth overflow = divu128(&rt, &ra, rb); 103fcf5ef2aSThomas Huth 104fcf5ef2aSThomas Huth if (unlikely(overflow)) { 105fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 106fcf5ef2aSThomas Huth } 107fcf5ef2aSThomas Huth 108fcf5ef2aSThomas Huth if (oe) { 109f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 110fcf5ef2aSThomas Huth } 111fcf5ef2aSThomas Huth 112fcf5ef2aSThomas Huth return rt; 113fcf5ef2aSThomas Huth } 114fcf5ef2aSThomas Huth 115fcf5ef2aSThomas Huth uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe) 116fcf5ef2aSThomas Huth { 117fcf5ef2aSThomas Huth int64_t rt = 0; 118fcf5ef2aSThomas Huth int64_t ra = (int64_t)rau; 119fcf5ef2aSThomas Huth int64_t rb = (int64_t)rbu; 120fcf5ef2aSThomas Huth int overflow = divs128(&rt, &ra, rb); 121fcf5ef2aSThomas Huth 122fcf5ef2aSThomas Huth if (unlikely(overflow)) { 123fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 124fcf5ef2aSThomas Huth } 125fcf5ef2aSThomas Huth 126fcf5ef2aSThomas Huth if (oe) { 127f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 128fcf5ef2aSThomas Huth } 129fcf5ef2aSThomas Huth 130fcf5ef2aSThomas Huth return rt; 131fcf5ef2aSThomas Huth } 132fcf5ef2aSThomas Huth 133fcf5ef2aSThomas Huth #endif 134fcf5ef2aSThomas Huth 135fcf5ef2aSThomas Huth 136fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 137fcf5ef2aSThomas Huth /* if x = 0xab, returns 0xababababababababa */ 138fcf5ef2aSThomas Huth #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff)) 139fcf5ef2aSThomas Huth 140fcf5ef2aSThomas Huth /* substract 1 from each byte, and with inverse, check if MSB is set at each 141fcf5ef2aSThomas Huth * byte. 142fcf5ef2aSThomas Huth * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80 143fcf5ef2aSThomas Huth * (0xFF & 0xFF) & 0x80 = 0x80 (zero found) 144fcf5ef2aSThomas Huth */ 145fcf5ef2aSThomas Huth #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80)) 146fcf5ef2aSThomas Huth 147fcf5ef2aSThomas Huth /* When you XOR the pattern and there is a match, that byte will be zero */ 148fcf5ef2aSThomas Huth #define hasvalue(x, n) (haszero((x) ^ pattern(n))) 149fcf5ef2aSThomas Huth 150fcf5ef2aSThomas Huth uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) 151fcf5ef2aSThomas Huth { 152efa73196SNikunj A Dadhania return hasvalue(rb, ra) ? CRF_GT : 0; 153fcf5ef2aSThomas Huth } 154fcf5ef2aSThomas Huth 155fcf5ef2aSThomas Huth #undef pattern 156fcf5ef2aSThomas Huth #undef haszero 157fcf5ef2aSThomas Huth #undef hasvalue 158fcf5ef2aSThomas Huth 159fcf5ef2aSThomas Huth /* Return invalid random number. 160fcf5ef2aSThomas Huth * 161fcf5ef2aSThomas Huth * FIXME: Add rng backend or other mechanism to get cryptographically suitable 162fcf5ef2aSThomas Huth * random number 163fcf5ef2aSThomas Huth */ 164fcf5ef2aSThomas Huth target_ulong helper_darn32(void) 165fcf5ef2aSThomas Huth { 166fcf5ef2aSThomas Huth return -1; 167fcf5ef2aSThomas Huth } 168fcf5ef2aSThomas Huth 169fcf5ef2aSThomas Huth target_ulong helper_darn64(void) 170fcf5ef2aSThomas Huth { 171fcf5ef2aSThomas Huth return -1; 172fcf5ef2aSThomas Huth } 173fcf5ef2aSThomas Huth 174fcf5ef2aSThomas Huth #endif 175fcf5ef2aSThomas Huth 176fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 177fcf5ef2aSThomas Huth 178fcf5ef2aSThomas Huth uint64_t helper_bpermd(uint64_t rs, uint64_t rb) 179fcf5ef2aSThomas Huth { 180fcf5ef2aSThomas Huth int i; 181fcf5ef2aSThomas Huth uint64_t ra = 0; 182fcf5ef2aSThomas Huth 183fcf5ef2aSThomas Huth for (i = 0; i < 8; i++) { 184fcf5ef2aSThomas Huth int index = (rs >> (i*8)) & 0xFF; 185fcf5ef2aSThomas Huth if (index < 64) { 186a6a444a8SCédric Le Goater if (rb & PPC_BIT(index)) { 187fcf5ef2aSThomas Huth ra |= 1 << i; 188fcf5ef2aSThomas Huth } 189fcf5ef2aSThomas Huth } 190fcf5ef2aSThomas Huth } 191fcf5ef2aSThomas Huth return ra; 192fcf5ef2aSThomas Huth } 193fcf5ef2aSThomas Huth 194fcf5ef2aSThomas Huth #endif 195fcf5ef2aSThomas Huth 196fcf5ef2aSThomas Huth target_ulong helper_cmpb(target_ulong rs, target_ulong rb) 197fcf5ef2aSThomas Huth { 198fcf5ef2aSThomas Huth target_ulong mask = 0xff; 199fcf5ef2aSThomas Huth target_ulong ra = 0; 200fcf5ef2aSThomas Huth int i; 201fcf5ef2aSThomas Huth 202fcf5ef2aSThomas Huth for (i = 0; i < sizeof(target_ulong); i++) { 203fcf5ef2aSThomas Huth if ((rs & mask) == (rb & mask)) { 204fcf5ef2aSThomas Huth ra |= mask; 205fcf5ef2aSThomas Huth } 206fcf5ef2aSThomas Huth mask <<= 8; 207fcf5ef2aSThomas Huth } 208fcf5ef2aSThomas Huth return ra; 209fcf5ef2aSThomas Huth } 210fcf5ef2aSThomas Huth 211fcf5ef2aSThomas Huth /* shift right arithmetic helper */ 212fcf5ef2aSThomas Huth target_ulong helper_sraw(CPUPPCState *env, target_ulong value, 213fcf5ef2aSThomas Huth target_ulong shift) 214fcf5ef2aSThomas Huth { 215fcf5ef2aSThomas Huth int32_t ret; 216fcf5ef2aSThomas Huth 217fcf5ef2aSThomas Huth if (likely(!(shift & 0x20))) { 218fcf5ef2aSThomas Huth if (likely((uint32_t)shift != 0)) { 219fcf5ef2aSThomas Huth shift &= 0x1f; 220fcf5ef2aSThomas Huth ret = (int32_t)value >> shift; 221fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) { 222af1c259fSSandipan Das env->ca32 = env->ca = 0; 223fcf5ef2aSThomas Huth } else { 224af1c259fSSandipan Das env->ca32 = env->ca = 1; 225fcf5ef2aSThomas Huth } 226fcf5ef2aSThomas Huth } else { 227fcf5ef2aSThomas Huth ret = (int32_t)value; 228af1c259fSSandipan Das env->ca32 = env->ca = 0; 229fcf5ef2aSThomas Huth } 230fcf5ef2aSThomas Huth } else { 231fcf5ef2aSThomas Huth ret = (int32_t)value >> 31; 232af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 233fcf5ef2aSThomas Huth } 234fcf5ef2aSThomas Huth return (target_long)ret; 235fcf5ef2aSThomas Huth } 236fcf5ef2aSThomas Huth 237fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 238fcf5ef2aSThomas Huth target_ulong helper_srad(CPUPPCState *env, target_ulong value, 239fcf5ef2aSThomas Huth target_ulong shift) 240fcf5ef2aSThomas Huth { 241fcf5ef2aSThomas Huth int64_t ret; 242fcf5ef2aSThomas Huth 243fcf5ef2aSThomas Huth if (likely(!(shift & 0x40))) { 244fcf5ef2aSThomas Huth if (likely((uint64_t)shift != 0)) { 245fcf5ef2aSThomas Huth shift &= 0x3f; 246fcf5ef2aSThomas Huth ret = (int64_t)value >> shift; 247fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) { 248af1c259fSSandipan Das env->ca32 = env->ca = 0; 249fcf5ef2aSThomas Huth } else { 250af1c259fSSandipan Das env->ca32 = env->ca = 1; 251fcf5ef2aSThomas Huth } 252fcf5ef2aSThomas Huth } else { 253fcf5ef2aSThomas Huth ret = (int64_t)value; 254af1c259fSSandipan Das env->ca32 = env->ca = 0; 255fcf5ef2aSThomas Huth } 256fcf5ef2aSThomas Huth } else { 257fcf5ef2aSThomas Huth ret = (int64_t)value >> 63; 258af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 259fcf5ef2aSThomas Huth } 260fcf5ef2aSThomas Huth return ret; 261fcf5ef2aSThomas Huth } 262fcf5ef2aSThomas Huth #endif 263fcf5ef2aSThomas Huth 264fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 265fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 266fcf5ef2aSThomas Huth { 26779770002SRichard Henderson /* Note that we don't fold past bytes */ 268fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 269fcf5ef2aSThomas Huth 0x5555555555555555ULL); 270fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 271fcf5ef2aSThomas Huth 0x3333333333333333ULL); 272fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 273fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 274fcf5ef2aSThomas Huth return val; 275fcf5ef2aSThomas Huth } 276fcf5ef2aSThomas Huth 277fcf5ef2aSThomas Huth target_ulong helper_popcntw(target_ulong val) 278fcf5ef2aSThomas Huth { 27979770002SRichard Henderson /* Note that we don't fold past words. */ 280fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 281fcf5ef2aSThomas Huth 0x5555555555555555ULL); 282fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 283fcf5ef2aSThomas Huth 0x3333333333333333ULL); 284fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 285fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 286fcf5ef2aSThomas Huth val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 287fcf5ef2aSThomas Huth 0x00ff00ff00ff00ffULL); 288fcf5ef2aSThomas Huth val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 289fcf5ef2aSThomas Huth 0x0000ffff0000ffffULL); 290fcf5ef2aSThomas Huth return val; 291fcf5ef2aSThomas Huth } 292fcf5ef2aSThomas Huth #else 293fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 294fcf5ef2aSThomas Huth { 29579770002SRichard Henderson /* Note that we don't fold past bytes */ 296fcf5ef2aSThomas Huth val = (val & 0x55555555) + ((val >> 1) & 0x55555555); 297fcf5ef2aSThomas Huth val = (val & 0x33333333) + ((val >> 2) & 0x33333333); 298fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f); 299fcf5ef2aSThomas Huth return val; 300fcf5ef2aSThomas Huth } 301fcf5ef2aSThomas Huth #endif 302fcf5ef2aSThomas Huth 303fcf5ef2aSThomas Huth /*****************************************************************************/ 304fcf5ef2aSThomas Huth /* PowerPC 601 specific instructions (POWER bridge) */ 305fcf5ef2aSThomas Huth target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2) 306fcf5ef2aSThomas Huth { 307fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 308fcf5ef2aSThomas Huth 309fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 310fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 311fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 312fcf5ef2aSThomas Huth return INT32_MIN; 313fcf5ef2aSThomas Huth } else { 314fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 315fcf5ef2aSThomas Huth return tmp / (int32_t)arg2; 316fcf5ef2aSThomas Huth } 317fcf5ef2aSThomas Huth } 318fcf5ef2aSThomas Huth 319fcf5ef2aSThomas Huth target_ulong helper_divo(CPUPPCState *env, target_ulong arg1, 320fcf5ef2aSThomas Huth target_ulong arg2) 321fcf5ef2aSThomas Huth { 322fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 323fcf5ef2aSThomas Huth 324fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 325fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 326fcf5ef2aSThomas Huth env->so = env->ov = 1; 327fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 328fcf5ef2aSThomas Huth return INT32_MIN; 329fcf5ef2aSThomas Huth } else { 330fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 331fcf5ef2aSThomas Huth tmp /= (int32_t)arg2; 332fcf5ef2aSThomas Huth if ((int32_t)tmp != tmp) { 333fcf5ef2aSThomas Huth env->so = env->ov = 1; 334fcf5ef2aSThomas Huth } else { 335fcf5ef2aSThomas Huth env->ov = 0; 336fcf5ef2aSThomas Huth } 337fcf5ef2aSThomas Huth return tmp; 338fcf5ef2aSThomas Huth } 339fcf5ef2aSThomas Huth } 340fcf5ef2aSThomas Huth 341fcf5ef2aSThomas Huth target_ulong helper_divs(CPUPPCState *env, target_ulong arg1, 342fcf5ef2aSThomas Huth target_ulong arg2) 343fcf5ef2aSThomas Huth { 344fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 345fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 346fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 347fcf5ef2aSThomas Huth return INT32_MIN; 348fcf5ef2aSThomas Huth } else { 349fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 350fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 351fcf5ef2aSThomas Huth } 352fcf5ef2aSThomas Huth } 353fcf5ef2aSThomas Huth 354fcf5ef2aSThomas Huth target_ulong helper_divso(CPUPPCState *env, target_ulong arg1, 355fcf5ef2aSThomas Huth target_ulong arg2) 356fcf5ef2aSThomas Huth { 357fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 358fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 359fcf5ef2aSThomas Huth env->so = env->ov = 1; 360fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 361fcf5ef2aSThomas Huth return INT32_MIN; 362fcf5ef2aSThomas Huth } else { 363fcf5ef2aSThomas Huth env->ov = 0; 364fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 365fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 366fcf5ef2aSThomas Huth } 367fcf5ef2aSThomas Huth } 368fcf5ef2aSThomas Huth 369fcf5ef2aSThomas Huth /*****************************************************************************/ 370fcf5ef2aSThomas Huth /* 602 specific instructions */ 371fcf5ef2aSThomas Huth /* mfrom is the most crazy instruction ever seen, imho ! */ 372fcf5ef2aSThomas Huth /* Real implementation uses a ROM table. Do the same */ 373fcf5ef2aSThomas Huth /* Extremely decomposed: 374fcf5ef2aSThomas Huth * -arg / 256 375fcf5ef2aSThomas Huth * return 256 * log10(10 + 1.0) + 0.5 376fcf5ef2aSThomas Huth */ 377fcf5ef2aSThomas Huth #if !defined(CONFIG_USER_ONLY) 378fcf5ef2aSThomas Huth target_ulong helper_602_mfrom(target_ulong arg) 379fcf5ef2aSThomas Huth { 380fcf5ef2aSThomas Huth if (likely(arg < 602)) { 3815b27a92dSPaolo Bonzini #include "mfrom_table.inc.c" 382fcf5ef2aSThomas Huth return mfrom_ROM_table[arg]; 383fcf5ef2aSThomas Huth } else { 384fcf5ef2aSThomas Huth return 0; 385fcf5ef2aSThomas Huth } 386fcf5ef2aSThomas Huth } 387fcf5ef2aSThomas Huth #endif 388fcf5ef2aSThomas Huth 389fcf5ef2aSThomas Huth /*****************************************************************************/ 390fcf5ef2aSThomas Huth /* Altivec extension helpers */ 391fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 392fcf5ef2aSThomas Huth #define HI_IDX 0 393fcf5ef2aSThomas Huth #define LO_IDX 1 394fcf5ef2aSThomas Huth #else 395fcf5ef2aSThomas Huth #define HI_IDX 1 396fcf5ef2aSThomas Huth #define LO_IDX 0 397fcf5ef2aSThomas Huth #endif 398fcf5ef2aSThomas Huth 399fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 400fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 401fcf5ef2aSThomas Huth for (index = 0; index < ARRAY_SIZE(r->element); index++) 402fcf5ef2aSThomas Huth #else 403fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 404fcf5ef2aSThomas Huth for (index = ARRAY_SIZE(r->element)-1; index >= 0; index--) 405fcf5ef2aSThomas Huth #endif 406fcf5ef2aSThomas Huth 407fcf5ef2aSThomas Huth /* Saturating arithmetic helpers. */ 408fcf5ef2aSThomas Huth #define SATCVT(from, to, from_type, to_type, min, max) \ 409fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 410fcf5ef2aSThomas Huth { \ 411fcf5ef2aSThomas Huth to_type r; \ 412fcf5ef2aSThomas Huth \ 413fcf5ef2aSThomas Huth if (x < (from_type)min) { \ 414fcf5ef2aSThomas Huth r = min; \ 415fcf5ef2aSThomas Huth *sat = 1; \ 416fcf5ef2aSThomas Huth } else if (x > (from_type)max) { \ 417fcf5ef2aSThomas Huth r = max; \ 418fcf5ef2aSThomas Huth *sat = 1; \ 419fcf5ef2aSThomas Huth } else { \ 420fcf5ef2aSThomas Huth r = x; \ 421fcf5ef2aSThomas Huth } \ 422fcf5ef2aSThomas Huth return r; \ 423fcf5ef2aSThomas Huth } 424fcf5ef2aSThomas Huth #define SATCVTU(from, to, from_type, to_type, min, max) \ 425fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 426fcf5ef2aSThomas Huth { \ 427fcf5ef2aSThomas Huth to_type r; \ 428fcf5ef2aSThomas Huth \ 429fcf5ef2aSThomas Huth if (x > (from_type)max) { \ 430fcf5ef2aSThomas Huth r = max; \ 431fcf5ef2aSThomas Huth *sat = 1; \ 432fcf5ef2aSThomas Huth } else { \ 433fcf5ef2aSThomas Huth r = x; \ 434fcf5ef2aSThomas Huth } \ 435fcf5ef2aSThomas Huth return r; \ 436fcf5ef2aSThomas Huth } 437fcf5ef2aSThomas Huth SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX) 438fcf5ef2aSThomas Huth SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX) 439fcf5ef2aSThomas Huth SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX) 440fcf5ef2aSThomas Huth 441fcf5ef2aSThomas Huth SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX) 442fcf5ef2aSThomas Huth SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX) 443fcf5ef2aSThomas Huth SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX) 444fcf5ef2aSThomas Huth SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX) 445fcf5ef2aSThomas Huth SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX) 446fcf5ef2aSThomas Huth SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX) 447fcf5ef2aSThomas Huth #undef SATCVT 448fcf5ef2aSThomas Huth #undef SATCVTU 449fcf5ef2aSThomas Huth 450fcf5ef2aSThomas Huth void helper_lvsl(ppc_avr_t *r, target_ulong sh) 451fcf5ef2aSThomas Huth { 452fcf5ef2aSThomas Huth int i, j = (sh & 0xf); 453fcf5ef2aSThomas Huth 454fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 455fcf5ef2aSThomas Huth r->u8[i] = j++; 456fcf5ef2aSThomas Huth } 457fcf5ef2aSThomas Huth } 458fcf5ef2aSThomas Huth 459fcf5ef2aSThomas Huth void helper_lvsr(ppc_avr_t *r, target_ulong sh) 460fcf5ef2aSThomas Huth { 461fcf5ef2aSThomas Huth int i, j = 0x10 - (sh & 0xf); 462fcf5ef2aSThomas Huth 463fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 464fcf5ef2aSThomas Huth r->u8[i] = j++; 465fcf5ef2aSThomas Huth } 466fcf5ef2aSThomas Huth } 467fcf5ef2aSThomas Huth 468fcf5ef2aSThomas Huth void helper_mtvscr(CPUPPCState *env, ppc_avr_t *r) 469fcf5ef2aSThomas Huth { 470fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 471fcf5ef2aSThomas Huth env->vscr = r->u32[3]; 472fcf5ef2aSThomas Huth #else 473fcf5ef2aSThomas Huth env->vscr = r->u32[0]; 474fcf5ef2aSThomas Huth #endif 475fcf5ef2aSThomas Huth set_flush_to_zero(vscr_nj, &env->vec_status); 476fcf5ef2aSThomas Huth } 477fcf5ef2aSThomas Huth 478fcf5ef2aSThomas Huth void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 479fcf5ef2aSThomas Huth { 480fcf5ef2aSThomas Huth int i; 481fcf5ef2aSThomas Huth 482fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 483fcf5ef2aSThomas Huth r->u32[i] = ~a->u32[i] < b->u32[i]; 484fcf5ef2aSThomas Huth } 485fcf5ef2aSThomas Huth } 486fcf5ef2aSThomas Huth 487fcf5ef2aSThomas Huth /* vprtybw */ 488fcf5ef2aSThomas Huth void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b) 489fcf5ef2aSThomas Huth { 490fcf5ef2aSThomas Huth int i; 491fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 492fcf5ef2aSThomas Huth uint64_t res = b->u32[i] ^ (b->u32[i] >> 16); 493fcf5ef2aSThomas Huth res ^= res >> 8; 494fcf5ef2aSThomas Huth r->u32[i] = res & 1; 495fcf5ef2aSThomas Huth } 496fcf5ef2aSThomas Huth } 497fcf5ef2aSThomas Huth 498fcf5ef2aSThomas Huth /* vprtybd */ 499fcf5ef2aSThomas Huth void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b) 500fcf5ef2aSThomas Huth { 501fcf5ef2aSThomas Huth int i; 502fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 503fcf5ef2aSThomas Huth uint64_t res = b->u64[i] ^ (b->u64[i] >> 32); 504fcf5ef2aSThomas Huth res ^= res >> 16; 505fcf5ef2aSThomas Huth res ^= res >> 8; 506fcf5ef2aSThomas Huth r->u64[i] = res & 1; 507fcf5ef2aSThomas Huth } 508fcf5ef2aSThomas Huth } 509fcf5ef2aSThomas Huth 510fcf5ef2aSThomas Huth /* vprtybq */ 511fcf5ef2aSThomas Huth void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b) 512fcf5ef2aSThomas Huth { 513fcf5ef2aSThomas Huth uint64_t res = b->u64[0] ^ b->u64[1]; 514fcf5ef2aSThomas Huth res ^= res >> 32; 515fcf5ef2aSThomas Huth res ^= res >> 16; 516fcf5ef2aSThomas Huth res ^= res >> 8; 517fcf5ef2aSThomas Huth r->u64[LO_IDX] = res & 1; 518fcf5ef2aSThomas Huth r->u64[HI_IDX] = 0; 519fcf5ef2aSThomas Huth } 520fcf5ef2aSThomas Huth 521fcf5ef2aSThomas Huth #define VARITH_DO(name, op, element) \ 522fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 523fcf5ef2aSThomas Huth { \ 524fcf5ef2aSThomas Huth int i; \ 525fcf5ef2aSThomas Huth \ 526fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 527fcf5ef2aSThomas Huth r->element[i] = a->element[i] op b->element[i]; \ 528fcf5ef2aSThomas Huth } \ 529fcf5ef2aSThomas Huth } 530fcf5ef2aSThomas Huth #define VARITH(suffix, element) \ 531fcf5ef2aSThomas Huth VARITH_DO(add##suffix, +, element) \ 532fcf5ef2aSThomas Huth VARITH_DO(sub##suffix, -, element) 533fcf5ef2aSThomas Huth VARITH(ubm, u8) 534fcf5ef2aSThomas Huth VARITH(uhm, u16) 535fcf5ef2aSThomas Huth VARITH(uwm, u32) 536fcf5ef2aSThomas Huth VARITH(udm, u64) 537fcf5ef2aSThomas Huth VARITH_DO(muluwm, *, u32) 538fcf5ef2aSThomas Huth #undef VARITH_DO 539fcf5ef2aSThomas Huth #undef VARITH 540fcf5ef2aSThomas Huth 541fcf5ef2aSThomas Huth #define VARITHFP(suffix, func) \ 542fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 543fcf5ef2aSThomas Huth ppc_avr_t *b) \ 544fcf5ef2aSThomas Huth { \ 545fcf5ef2aSThomas Huth int i; \ 546fcf5ef2aSThomas Huth \ 54705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 54805ee3e8aSMark Cave-Ayland r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \ 549fcf5ef2aSThomas Huth } \ 550fcf5ef2aSThomas Huth } 551fcf5ef2aSThomas Huth VARITHFP(addfp, float32_add) 552fcf5ef2aSThomas Huth VARITHFP(subfp, float32_sub) 553fcf5ef2aSThomas Huth VARITHFP(minfp, float32_min) 554fcf5ef2aSThomas Huth VARITHFP(maxfp, float32_max) 555fcf5ef2aSThomas Huth #undef VARITHFP 556fcf5ef2aSThomas Huth 557fcf5ef2aSThomas Huth #define VARITHFPFMA(suffix, type) \ 558fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 559fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) \ 560fcf5ef2aSThomas Huth { \ 561fcf5ef2aSThomas Huth int i; \ 56205ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 56305ee3e8aSMark Cave-Ayland r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \ 564fcf5ef2aSThomas Huth type, &env->vec_status); \ 565fcf5ef2aSThomas Huth } \ 566fcf5ef2aSThomas Huth } 567fcf5ef2aSThomas Huth VARITHFPFMA(maddfp, 0); 568fcf5ef2aSThomas Huth VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c); 569fcf5ef2aSThomas Huth #undef VARITHFPFMA 570fcf5ef2aSThomas Huth 571fcf5ef2aSThomas Huth #define VARITHSAT_CASE(type, op, cvt, element) \ 572fcf5ef2aSThomas Huth { \ 573fcf5ef2aSThomas Huth type result = (type)a->element[i] op (type)b->element[i]; \ 574fcf5ef2aSThomas Huth r->element[i] = cvt(result, &sat); \ 575fcf5ef2aSThomas Huth } 576fcf5ef2aSThomas Huth 577fcf5ef2aSThomas Huth #define VARITHSAT_DO(name, op, optype, cvt, element) \ 578fcf5ef2aSThomas Huth void helper_v##name(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 579fcf5ef2aSThomas Huth ppc_avr_t *b) \ 580fcf5ef2aSThomas Huth { \ 581fcf5ef2aSThomas Huth int sat = 0; \ 582fcf5ef2aSThomas Huth int i; \ 583fcf5ef2aSThomas Huth \ 584fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 585fcf5ef2aSThomas Huth switch (sizeof(r->element[0])) { \ 586fcf5ef2aSThomas Huth case 1: \ 587fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 588fcf5ef2aSThomas Huth break; \ 589fcf5ef2aSThomas Huth case 2: \ 590fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 591fcf5ef2aSThomas Huth break; \ 592fcf5ef2aSThomas Huth case 4: \ 593fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 594fcf5ef2aSThomas Huth break; \ 595fcf5ef2aSThomas Huth } \ 596fcf5ef2aSThomas Huth } \ 597fcf5ef2aSThomas Huth if (sat) { \ 598fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); \ 599fcf5ef2aSThomas Huth } \ 600fcf5ef2aSThomas Huth } 601fcf5ef2aSThomas Huth #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \ 602fcf5ef2aSThomas Huth VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \ 603fcf5ef2aSThomas Huth VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element) 604fcf5ef2aSThomas Huth #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \ 605fcf5ef2aSThomas Huth VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \ 606fcf5ef2aSThomas Huth VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element) 607fcf5ef2aSThomas Huth VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb) 608fcf5ef2aSThomas Huth VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh) 609fcf5ef2aSThomas Huth VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw) 610fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub) 611fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh) 612fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw) 613fcf5ef2aSThomas Huth #undef VARITHSAT_CASE 614fcf5ef2aSThomas Huth #undef VARITHSAT_DO 615fcf5ef2aSThomas Huth #undef VARITHSAT_SIGNED 616fcf5ef2aSThomas Huth #undef VARITHSAT_UNSIGNED 617fcf5ef2aSThomas Huth 618fcf5ef2aSThomas Huth #define VAVG_DO(name, element, etype) \ 619fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 620fcf5ef2aSThomas Huth { \ 621fcf5ef2aSThomas Huth int i; \ 622fcf5ef2aSThomas Huth \ 623fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 624fcf5ef2aSThomas Huth etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \ 625fcf5ef2aSThomas Huth r->element[i] = x >> 1; \ 626fcf5ef2aSThomas Huth } \ 627fcf5ef2aSThomas Huth } 628fcf5ef2aSThomas Huth 629fcf5ef2aSThomas Huth #define VAVG(type, signed_element, signed_type, unsigned_element, \ 630fcf5ef2aSThomas Huth unsigned_type) \ 631fcf5ef2aSThomas Huth VAVG_DO(avgs##type, signed_element, signed_type) \ 632fcf5ef2aSThomas Huth VAVG_DO(avgu##type, unsigned_element, unsigned_type) 633fcf5ef2aSThomas Huth VAVG(b, s8, int16_t, u8, uint16_t) 634fcf5ef2aSThomas Huth VAVG(h, s16, int32_t, u16, uint32_t) 635fcf5ef2aSThomas Huth VAVG(w, s32, int64_t, u32, uint64_t) 636fcf5ef2aSThomas Huth #undef VAVG_DO 637fcf5ef2aSThomas Huth #undef VAVG 638fcf5ef2aSThomas Huth 639fcf5ef2aSThomas Huth #define VABSDU_DO(name, element) \ 640fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 641fcf5ef2aSThomas Huth { \ 642fcf5ef2aSThomas Huth int i; \ 643fcf5ef2aSThomas Huth \ 644fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 645fcf5ef2aSThomas Huth r->element[i] = (a->element[i] > b->element[i]) ? \ 646fcf5ef2aSThomas Huth (a->element[i] - b->element[i]) : \ 647fcf5ef2aSThomas Huth (b->element[i] - a->element[i]); \ 648fcf5ef2aSThomas Huth } \ 649fcf5ef2aSThomas Huth } 650fcf5ef2aSThomas Huth 651fcf5ef2aSThomas Huth /* VABSDU - Vector absolute difference unsigned 652fcf5ef2aSThomas Huth * name - instruction mnemonic suffix (b: byte, h: halfword, w: word) 653fcf5ef2aSThomas Huth * element - element type to access from vector 654fcf5ef2aSThomas Huth */ 655fcf5ef2aSThomas Huth #define VABSDU(type, element) \ 656fcf5ef2aSThomas Huth VABSDU_DO(absdu##type, element) 657fcf5ef2aSThomas Huth VABSDU(b, u8) 658fcf5ef2aSThomas Huth VABSDU(h, u16) 659fcf5ef2aSThomas Huth VABSDU(w, u32) 660fcf5ef2aSThomas Huth #undef VABSDU_DO 661fcf5ef2aSThomas Huth #undef VABSDU 662fcf5ef2aSThomas Huth 663fcf5ef2aSThomas Huth #define VCF(suffix, cvt, element) \ 664fcf5ef2aSThomas Huth void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \ 665fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 666fcf5ef2aSThomas Huth { \ 667fcf5ef2aSThomas Huth int i; \ 668fcf5ef2aSThomas Huth \ 66905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 670fcf5ef2aSThomas Huth float32 t = cvt(b->element[i], &env->vec_status); \ 67105ee3e8aSMark Cave-Ayland r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \ 672fcf5ef2aSThomas Huth } \ 673fcf5ef2aSThomas Huth } 674fcf5ef2aSThomas Huth VCF(ux, uint32_to_float32, u32) 675fcf5ef2aSThomas Huth VCF(sx, int32_to_float32, s32) 676fcf5ef2aSThomas Huth #undef VCF 677fcf5ef2aSThomas Huth 678fcf5ef2aSThomas Huth #define VCMP_DO(suffix, compare, element, record) \ 679fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 680fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 681fcf5ef2aSThomas Huth { \ 682fcf5ef2aSThomas Huth uint64_t ones = (uint64_t)-1; \ 683fcf5ef2aSThomas Huth uint64_t all = ones; \ 684fcf5ef2aSThomas Huth uint64_t none = 0; \ 685fcf5ef2aSThomas Huth int i; \ 686fcf5ef2aSThomas Huth \ 687fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 688fcf5ef2aSThomas Huth uint64_t result = (a->element[i] compare b->element[i] ? \ 689fcf5ef2aSThomas Huth ones : 0x0); \ 690fcf5ef2aSThomas Huth switch (sizeof(a->element[0])) { \ 691fcf5ef2aSThomas Huth case 8: \ 692fcf5ef2aSThomas Huth r->u64[i] = result; \ 693fcf5ef2aSThomas Huth break; \ 694fcf5ef2aSThomas Huth case 4: \ 695fcf5ef2aSThomas Huth r->u32[i] = result; \ 696fcf5ef2aSThomas Huth break; \ 697fcf5ef2aSThomas Huth case 2: \ 698fcf5ef2aSThomas Huth r->u16[i] = result; \ 699fcf5ef2aSThomas Huth break; \ 700fcf5ef2aSThomas Huth case 1: \ 701fcf5ef2aSThomas Huth r->u8[i] = result; \ 702fcf5ef2aSThomas Huth break; \ 703fcf5ef2aSThomas Huth } \ 704fcf5ef2aSThomas Huth all &= result; \ 705fcf5ef2aSThomas Huth none |= result; \ 706fcf5ef2aSThomas Huth } \ 707fcf5ef2aSThomas Huth if (record) { \ 708fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 709fcf5ef2aSThomas Huth } \ 710fcf5ef2aSThomas Huth } 711fcf5ef2aSThomas Huth #define VCMP(suffix, compare, element) \ 712fcf5ef2aSThomas Huth VCMP_DO(suffix, compare, element, 0) \ 713fcf5ef2aSThomas Huth VCMP_DO(suffix##_dot, compare, element, 1) 714fcf5ef2aSThomas Huth VCMP(equb, ==, u8) 715fcf5ef2aSThomas Huth VCMP(equh, ==, u16) 716fcf5ef2aSThomas Huth VCMP(equw, ==, u32) 717fcf5ef2aSThomas Huth VCMP(equd, ==, u64) 718fcf5ef2aSThomas Huth VCMP(gtub, >, u8) 719fcf5ef2aSThomas Huth VCMP(gtuh, >, u16) 720fcf5ef2aSThomas Huth VCMP(gtuw, >, u32) 721fcf5ef2aSThomas Huth VCMP(gtud, >, u64) 722fcf5ef2aSThomas Huth VCMP(gtsb, >, s8) 723fcf5ef2aSThomas Huth VCMP(gtsh, >, s16) 724fcf5ef2aSThomas Huth VCMP(gtsw, >, s32) 725fcf5ef2aSThomas Huth VCMP(gtsd, >, s64) 726fcf5ef2aSThomas Huth #undef VCMP_DO 727fcf5ef2aSThomas Huth #undef VCMP 728fcf5ef2aSThomas Huth 729fcf5ef2aSThomas Huth #define VCMPNE_DO(suffix, element, etype, cmpzero, record) \ 730fcf5ef2aSThomas Huth void helper_vcmpne##suffix(CPUPPCState *env, ppc_avr_t *r, \ 731fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 732fcf5ef2aSThomas Huth { \ 733fcf5ef2aSThomas Huth etype ones = (etype)-1; \ 734fcf5ef2aSThomas Huth etype all = ones; \ 735fcf5ef2aSThomas Huth etype result, none = 0; \ 736fcf5ef2aSThomas Huth int i; \ 737fcf5ef2aSThomas Huth \ 738fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 739fcf5ef2aSThomas Huth if (cmpzero) { \ 740fcf5ef2aSThomas Huth result = ((a->element[i] == 0) \ 741fcf5ef2aSThomas Huth || (b->element[i] == 0) \ 742fcf5ef2aSThomas Huth || (a->element[i] != b->element[i]) ? \ 743fcf5ef2aSThomas Huth ones : 0x0); \ 744fcf5ef2aSThomas Huth } else { \ 745fcf5ef2aSThomas Huth result = (a->element[i] != b->element[i]) ? ones : 0x0; \ 746fcf5ef2aSThomas Huth } \ 747fcf5ef2aSThomas Huth r->element[i] = result; \ 748fcf5ef2aSThomas Huth all &= result; \ 749fcf5ef2aSThomas Huth none |= result; \ 750fcf5ef2aSThomas Huth } \ 751fcf5ef2aSThomas Huth if (record) { \ 752fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 753fcf5ef2aSThomas Huth } \ 754fcf5ef2aSThomas Huth } 755fcf5ef2aSThomas Huth 756fcf5ef2aSThomas Huth /* VCMPNEZ - Vector compare not equal to zero 757fcf5ef2aSThomas Huth * suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word) 758fcf5ef2aSThomas Huth * element - element type to access from vector 759fcf5ef2aSThomas Huth */ 760fcf5ef2aSThomas Huth #define VCMPNE(suffix, element, etype, cmpzero) \ 761fcf5ef2aSThomas Huth VCMPNE_DO(suffix, element, etype, cmpzero, 0) \ 762fcf5ef2aSThomas Huth VCMPNE_DO(suffix##_dot, element, etype, cmpzero, 1) 763fcf5ef2aSThomas Huth VCMPNE(zb, u8, uint8_t, 1) 764fcf5ef2aSThomas Huth VCMPNE(zh, u16, uint16_t, 1) 765fcf5ef2aSThomas Huth VCMPNE(zw, u32, uint32_t, 1) 766fcf5ef2aSThomas Huth VCMPNE(b, u8, uint8_t, 0) 767fcf5ef2aSThomas Huth VCMPNE(h, u16, uint16_t, 0) 768fcf5ef2aSThomas Huth VCMPNE(w, u32, uint32_t, 0) 769fcf5ef2aSThomas Huth #undef VCMPNE_DO 770fcf5ef2aSThomas Huth #undef VCMPNE 771fcf5ef2aSThomas Huth 772fcf5ef2aSThomas Huth #define VCMPFP_DO(suffix, compare, order, record) \ 773fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 774fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 775fcf5ef2aSThomas Huth { \ 776fcf5ef2aSThomas Huth uint32_t ones = (uint32_t)-1; \ 777fcf5ef2aSThomas Huth uint32_t all = ones; \ 778fcf5ef2aSThomas Huth uint32_t none = 0; \ 779fcf5ef2aSThomas Huth int i; \ 780fcf5ef2aSThomas Huth \ 78105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 782fcf5ef2aSThomas Huth uint32_t result; \ 78305ee3e8aSMark Cave-Ayland int rel = float32_compare_quiet(a->f32[i], b->f32[i], \ 784fcf5ef2aSThomas Huth &env->vec_status); \ 785fcf5ef2aSThomas Huth if (rel == float_relation_unordered) { \ 786fcf5ef2aSThomas Huth result = 0; \ 787fcf5ef2aSThomas Huth } else if (rel compare order) { \ 788fcf5ef2aSThomas Huth result = ones; \ 789fcf5ef2aSThomas Huth } else { \ 790fcf5ef2aSThomas Huth result = 0; \ 791fcf5ef2aSThomas Huth } \ 792fcf5ef2aSThomas Huth r->u32[i] = result; \ 793fcf5ef2aSThomas Huth all &= result; \ 794fcf5ef2aSThomas Huth none |= result; \ 795fcf5ef2aSThomas Huth } \ 796fcf5ef2aSThomas Huth if (record) { \ 797fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 798fcf5ef2aSThomas Huth } \ 799fcf5ef2aSThomas Huth } 800fcf5ef2aSThomas Huth #define VCMPFP(suffix, compare, order) \ 801fcf5ef2aSThomas Huth VCMPFP_DO(suffix, compare, order, 0) \ 802fcf5ef2aSThomas Huth VCMPFP_DO(suffix##_dot, compare, order, 1) 803fcf5ef2aSThomas Huth VCMPFP(eqfp, ==, float_relation_equal) 804fcf5ef2aSThomas Huth VCMPFP(gefp, !=, float_relation_less) 805fcf5ef2aSThomas Huth VCMPFP(gtfp, ==, float_relation_greater) 806fcf5ef2aSThomas Huth #undef VCMPFP_DO 807fcf5ef2aSThomas Huth #undef VCMPFP 808fcf5ef2aSThomas Huth 809fcf5ef2aSThomas Huth static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r, 810fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b, int record) 811fcf5ef2aSThomas Huth { 812fcf5ef2aSThomas Huth int i; 813fcf5ef2aSThomas Huth int all_in = 0; 814fcf5ef2aSThomas Huth 81505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 81605ee3e8aSMark Cave-Ayland int le_rel = float32_compare_quiet(a->f32[i], b->f32[i], 81705ee3e8aSMark Cave-Ayland &env->vec_status); 818fcf5ef2aSThomas Huth if (le_rel == float_relation_unordered) { 819fcf5ef2aSThomas Huth r->u32[i] = 0xc0000000; 820fcf5ef2aSThomas Huth all_in = 1; 821fcf5ef2aSThomas Huth } else { 82205ee3e8aSMark Cave-Ayland float32 bneg = float32_chs(b->f32[i]); 82305ee3e8aSMark Cave-Ayland int ge_rel = float32_compare_quiet(a->f32[i], bneg, 82405ee3e8aSMark Cave-Ayland &env->vec_status); 825fcf5ef2aSThomas Huth int le = le_rel != float_relation_greater; 826fcf5ef2aSThomas Huth int ge = ge_rel != float_relation_less; 827fcf5ef2aSThomas Huth 828fcf5ef2aSThomas Huth r->u32[i] = ((!le) << 31) | ((!ge) << 30); 829fcf5ef2aSThomas Huth all_in |= (!le | !ge); 830fcf5ef2aSThomas Huth } 831fcf5ef2aSThomas Huth } 832fcf5ef2aSThomas Huth if (record) { 833fcf5ef2aSThomas Huth env->crf[6] = (all_in == 0) << 1; 834fcf5ef2aSThomas Huth } 835fcf5ef2aSThomas Huth } 836fcf5ef2aSThomas Huth 837fcf5ef2aSThomas Huth void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 838fcf5ef2aSThomas Huth { 839fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 0); 840fcf5ef2aSThomas Huth } 841fcf5ef2aSThomas Huth 842fcf5ef2aSThomas Huth void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 843fcf5ef2aSThomas Huth ppc_avr_t *b) 844fcf5ef2aSThomas Huth { 845fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 1); 846fcf5ef2aSThomas Huth } 847fcf5ef2aSThomas Huth 848fcf5ef2aSThomas Huth #define VCT(suffix, satcvt, element) \ 849fcf5ef2aSThomas Huth void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \ 850fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 851fcf5ef2aSThomas Huth { \ 852fcf5ef2aSThomas Huth int i; \ 853fcf5ef2aSThomas Huth int sat = 0; \ 854fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 855fcf5ef2aSThomas Huth \ 856fcf5ef2aSThomas Huth set_float_rounding_mode(float_round_to_zero, &s); \ 85705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 85805ee3e8aSMark Cave-Ayland if (float32_is_any_nan(b->f32[i])) { \ 859fcf5ef2aSThomas Huth r->element[i] = 0; \ 860fcf5ef2aSThomas Huth } else { \ 86105ee3e8aSMark Cave-Ayland float64 t = float32_to_float64(b->f32[i], &s); \ 862fcf5ef2aSThomas Huth int64_t j; \ 863fcf5ef2aSThomas Huth \ 864fcf5ef2aSThomas Huth t = float64_scalbn(t, uim, &s); \ 865fcf5ef2aSThomas Huth j = float64_to_int64(t, &s); \ 866fcf5ef2aSThomas Huth r->element[i] = satcvt(j, &sat); \ 867fcf5ef2aSThomas Huth } \ 868fcf5ef2aSThomas Huth } \ 869fcf5ef2aSThomas Huth if (sat) { \ 870fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); \ 871fcf5ef2aSThomas Huth } \ 872fcf5ef2aSThomas Huth } 873fcf5ef2aSThomas Huth VCT(uxs, cvtsduw, u32) 874fcf5ef2aSThomas Huth VCT(sxs, cvtsdsw, s32) 875fcf5ef2aSThomas Huth #undef VCT 876fcf5ef2aSThomas Huth 877fcf5ef2aSThomas Huth target_ulong helper_vclzlsbb(ppc_avr_t *r) 878fcf5ef2aSThomas Huth { 879fcf5ef2aSThomas Huth target_ulong count = 0; 880fcf5ef2aSThomas Huth int i; 881fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 882fcf5ef2aSThomas Huth if (r->u8[i] & 0x01) { 883fcf5ef2aSThomas Huth break; 884fcf5ef2aSThomas Huth } 885fcf5ef2aSThomas Huth count++; 886fcf5ef2aSThomas Huth } 887fcf5ef2aSThomas Huth return count; 888fcf5ef2aSThomas Huth } 889fcf5ef2aSThomas Huth 890fcf5ef2aSThomas Huth target_ulong helper_vctzlsbb(ppc_avr_t *r) 891fcf5ef2aSThomas Huth { 892fcf5ef2aSThomas Huth target_ulong count = 0; 893fcf5ef2aSThomas Huth int i; 894fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 895fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 896fcf5ef2aSThomas Huth #else 897fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 898fcf5ef2aSThomas Huth #endif 899fcf5ef2aSThomas Huth if (r->u8[i] & 0x01) { 900fcf5ef2aSThomas Huth break; 901fcf5ef2aSThomas Huth } 902fcf5ef2aSThomas Huth count++; 903fcf5ef2aSThomas Huth } 904fcf5ef2aSThomas Huth return count; 905fcf5ef2aSThomas Huth } 906fcf5ef2aSThomas Huth 907fcf5ef2aSThomas Huth void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 908fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 909fcf5ef2aSThomas Huth { 910fcf5ef2aSThomas Huth int sat = 0; 911fcf5ef2aSThomas Huth int i; 912fcf5ef2aSThomas Huth 913fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 914fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 915fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 916fcf5ef2aSThomas Huth 917fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 918fcf5ef2aSThomas Huth } 919fcf5ef2aSThomas Huth 920fcf5ef2aSThomas Huth if (sat) { 921fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 922fcf5ef2aSThomas Huth } 923fcf5ef2aSThomas Huth } 924fcf5ef2aSThomas Huth 925fcf5ef2aSThomas Huth void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 926fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 927fcf5ef2aSThomas Huth { 928fcf5ef2aSThomas Huth int sat = 0; 929fcf5ef2aSThomas Huth int i; 930fcf5ef2aSThomas Huth 931fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 932fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i] + 0x00004000; 933fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 934fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 935fcf5ef2aSThomas Huth } 936fcf5ef2aSThomas Huth 937fcf5ef2aSThomas Huth if (sat) { 938fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 939fcf5ef2aSThomas Huth } 940fcf5ef2aSThomas Huth } 941fcf5ef2aSThomas Huth 942fcf5ef2aSThomas Huth #define VMINMAX_DO(name, compare, element) \ 943fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 944fcf5ef2aSThomas Huth { \ 945fcf5ef2aSThomas Huth int i; \ 946fcf5ef2aSThomas Huth \ 947fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 948fcf5ef2aSThomas Huth if (a->element[i] compare b->element[i]) { \ 949fcf5ef2aSThomas Huth r->element[i] = b->element[i]; \ 950fcf5ef2aSThomas Huth } else { \ 951fcf5ef2aSThomas Huth r->element[i] = a->element[i]; \ 952fcf5ef2aSThomas Huth } \ 953fcf5ef2aSThomas Huth } \ 954fcf5ef2aSThomas Huth } 955fcf5ef2aSThomas Huth #define VMINMAX(suffix, element) \ 956fcf5ef2aSThomas Huth VMINMAX_DO(min##suffix, >, element) \ 957fcf5ef2aSThomas Huth VMINMAX_DO(max##suffix, <, element) 958fcf5ef2aSThomas Huth VMINMAX(sb, s8) 959fcf5ef2aSThomas Huth VMINMAX(sh, s16) 960fcf5ef2aSThomas Huth VMINMAX(sw, s32) 961fcf5ef2aSThomas Huth VMINMAX(sd, s64) 962fcf5ef2aSThomas Huth VMINMAX(ub, u8) 963fcf5ef2aSThomas Huth VMINMAX(uh, u16) 964fcf5ef2aSThomas Huth VMINMAX(uw, u32) 965fcf5ef2aSThomas Huth VMINMAX(ud, u64) 966fcf5ef2aSThomas Huth #undef VMINMAX_DO 967fcf5ef2aSThomas Huth #undef VMINMAX 968fcf5ef2aSThomas Huth 969fcf5ef2aSThomas Huth void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 970fcf5ef2aSThomas Huth { 971fcf5ef2aSThomas Huth int i; 972fcf5ef2aSThomas Huth 973fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 974fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 975fcf5ef2aSThomas Huth r->s16[i] = (int16_t) (prod + c->s16[i]); 976fcf5ef2aSThomas Huth } 977fcf5ef2aSThomas Huth } 978fcf5ef2aSThomas Huth 979fcf5ef2aSThomas Huth #define VMRG_DO(name, element, highp) \ 980fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 981fcf5ef2aSThomas Huth { \ 982fcf5ef2aSThomas Huth ppc_avr_t result; \ 983fcf5ef2aSThomas Huth int i; \ 984fcf5ef2aSThomas Huth size_t n_elems = ARRAY_SIZE(r->element); \ 985fcf5ef2aSThomas Huth \ 986fcf5ef2aSThomas Huth for (i = 0; i < n_elems / 2; i++) { \ 987fcf5ef2aSThomas Huth if (highp) { \ 988fcf5ef2aSThomas Huth result.element[i*2+HI_IDX] = a->element[i]; \ 989fcf5ef2aSThomas Huth result.element[i*2+LO_IDX] = b->element[i]; \ 990fcf5ef2aSThomas Huth } else { \ 991fcf5ef2aSThomas Huth result.element[n_elems - i * 2 - (1 + HI_IDX)] = \ 992fcf5ef2aSThomas Huth b->element[n_elems - i - 1]; \ 993fcf5ef2aSThomas Huth result.element[n_elems - i * 2 - (1 + LO_IDX)] = \ 994fcf5ef2aSThomas Huth a->element[n_elems - i - 1]; \ 995fcf5ef2aSThomas Huth } \ 996fcf5ef2aSThomas Huth } \ 997fcf5ef2aSThomas Huth *r = result; \ 998fcf5ef2aSThomas Huth } 999fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1000fcf5ef2aSThomas Huth #define MRGHI 0 1001fcf5ef2aSThomas Huth #define MRGLO 1 1002fcf5ef2aSThomas Huth #else 1003fcf5ef2aSThomas Huth #define MRGHI 1 1004fcf5ef2aSThomas Huth #define MRGLO 0 1005fcf5ef2aSThomas Huth #endif 1006fcf5ef2aSThomas Huth #define VMRG(suffix, element) \ 1007fcf5ef2aSThomas Huth VMRG_DO(mrgl##suffix, element, MRGHI) \ 1008fcf5ef2aSThomas Huth VMRG_DO(mrgh##suffix, element, MRGLO) 1009fcf5ef2aSThomas Huth VMRG(b, u8) 1010fcf5ef2aSThomas Huth VMRG(h, u16) 1011fcf5ef2aSThomas Huth VMRG(w, u32) 1012fcf5ef2aSThomas Huth #undef VMRG_DO 1013fcf5ef2aSThomas Huth #undef VMRG 1014fcf5ef2aSThomas Huth #undef MRGHI 1015fcf5ef2aSThomas Huth #undef MRGLO 1016fcf5ef2aSThomas Huth 1017fcf5ef2aSThomas Huth void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1018fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1019fcf5ef2aSThomas Huth { 1020fcf5ef2aSThomas Huth int32_t prod[16]; 1021fcf5ef2aSThomas Huth int i; 1022fcf5ef2aSThomas Huth 1023fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s8); i++) { 1024fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s8[i] * b->u8[i]; 1025fcf5ef2aSThomas Huth } 1026fcf5ef2aSThomas Huth 1027fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1028fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] + 1029fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1030fcf5ef2aSThomas Huth } 1031fcf5ef2aSThomas Huth } 1032fcf5ef2aSThomas Huth 1033fcf5ef2aSThomas Huth void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1034fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1035fcf5ef2aSThomas Huth { 1036fcf5ef2aSThomas Huth int32_t prod[8]; 1037fcf5ef2aSThomas Huth int i; 1038fcf5ef2aSThomas Huth 1039fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1040fcf5ef2aSThomas Huth prod[i] = a->s16[i] * b->s16[i]; 1041fcf5ef2aSThomas Huth } 1042fcf5ef2aSThomas Huth 1043fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1044fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1045fcf5ef2aSThomas Huth } 1046fcf5ef2aSThomas Huth } 1047fcf5ef2aSThomas Huth 1048fcf5ef2aSThomas Huth void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1049fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1050fcf5ef2aSThomas Huth { 1051fcf5ef2aSThomas Huth int32_t prod[8]; 1052fcf5ef2aSThomas Huth int i; 1053fcf5ef2aSThomas Huth int sat = 0; 1054fcf5ef2aSThomas Huth 1055fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1056fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s16[i] * b->s16[i]; 1057fcf5ef2aSThomas Huth } 1058fcf5ef2aSThomas Huth 1059fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1060fcf5ef2aSThomas Huth int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1061fcf5ef2aSThomas Huth 1062fcf5ef2aSThomas Huth r->u32[i] = cvtsdsw(t, &sat); 1063fcf5ef2aSThomas Huth } 1064fcf5ef2aSThomas Huth 1065fcf5ef2aSThomas Huth if (sat) { 1066fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 1067fcf5ef2aSThomas Huth } 1068fcf5ef2aSThomas Huth } 1069fcf5ef2aSThomas Huth 1070fcf5ef2aSThomas Huth void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1071fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1072fcf5ef2aSThomas Huth { 1073fcf5ef2aSThomas Huth uint16_t prod[16]; 1074fcf5ef2aSThomas Huth int i; 1075fcf5ef2aSThomas Huth 1076fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1077fcf5ef2aSThomas Huth prod[i] = a->u8[i] * b->u8[i]; 1078fcf5ef2aSThomas Huth } 1079fcf5ef2aSThomas Huth 1080fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1081fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] + 1082fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1083fcf5ef2aSThomas Huth } 1084fcf5ef2aSThomas Huth } 1085fcf5ef2aSThomas Huth 1086fcf5ef2aSThomas Huth void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1087fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1088fcf5ef2aSThomas Huth { 1089fcf5ef2aSThomas Huth uint32_t prod[8]; 1090fcf5ef2aSThomas Huth int i; 1091fcf5ef2aSThomas Huth 1092fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1093fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1094fcf5ef2aSThomas Huth } 1095fcf5ef2aSThomas Huth 1096fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1097fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1098fcf5ef2aSThomas Huth } 1099fcf5ef2aSThomas Huth } 1100fcf5ef2aSThomas Huth 1101fcf5ef2aSThomas Huth void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1102fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1103fcf5ef2aSThomas Huth { 1104fcf5ef2aSThomas Huth uint32_t prod[8]; 1105fcf5ef2aSThomas Huth int i; 1106fcf5ef2aSThomas Huth int sat = 0; 1107fcf5ef2aSThomas Huth 1108fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1109fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1110fcf5ef2aSThomas Huth } 1111fcf5ef2aSThomas Huth 1112fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1113fcf5ef2aSThomas Huth uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1114fcf5ef2aSThomas Huth 1115fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1116fcf5ef2aSThomas Huth } 1117fcf5ef2aSThomas Huth 1118fcf5ef2aSThomas Huth if (sat) { 1119fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 1120fcf5ef2aSThomas Huth } 1121fcf5ef2aSThomas Huth } 1122fcf5ef2aSThomas Huth 1123fcf5ef2aSThomas Huth #define VMUL_DO(name, mul_element, prod_element, cast, evenp) \ 1124fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1125fcf5ef2aSThomas Huth { \ 1126fcf5ef2aSThomas Huth int i; \ 1127fcf5ef2aSThomas Huth \ 1128fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, prod_element) { \ 1129fcf5ef2aSThomas Huth if (evenp) { \ 1130fcf5ef2aSThomas Huth r->prod_element[i] = \ 1131fcf5ef2aSThomas Huth (cast)a->mul_element[i * 2 + HI_IDX] * \ 1132fcf5ef2aSThomas Huth (cast)b->mul_element[i * 2 + HI_IDX]; \ 1133fcf5ef2aSThomas Huth } else { \ 1134fcf5ef2aSThomas Huth r->prod_element[i] = \ 1135fcf5ef2aSThomas Huth (cast)a->mul_element[i * 2 + LO_IDX] * \ 1136fcf5ef2aSThomas Huth (cast)b->mul_element[i * 2 + LO_IDX]; \ 1137fcf5ef2aSThomas Huth } \ 1138fcf5ef2aSThomas Huth } \ 1139fcf5ef2aSThomas Huth } 1140fcf5ef2aSThomas Huth #define VMUL(suffix, mul_element, prod_element, cast) \ 1141fcf5ef2aSThomas Huth VMUL_DO(mule##suffix, mul_element, prod_element, cast, 1) \ 1142fcf5ef2aSThomas Huth VMUL_DO(mulo##suffix, mul_element, prod_element, cast, 0) 1143fcf5ef2aSThomas Huth VMUL(sb, s8, s16, int16_t) 1144fcf5ef2aSThomas Huth VMUL(sh, s16, s32, int32_t) 1145fcf5ef2aSThomas Huth VMUL(sw, s32, s64, int64_t) 1146fcf5ef2aSThomas Huth VMUL(ub, u8, u16, uint16_t) 1147fcf5ef2aSThomas Huth VMUL(uh, u16, u32, uint32_t) 1148fcf5ef2aSThomas Huth VMUL(uw, u32, u64, uint64_t) 1149fcf5ef2aSThomas Huth #undef VMUL_DO 1150fcf5ef2aSThomas Huth #undef VMUL 1151fcf5ef2aSThomas Huth 1152fcf5ef2aSThomas Huth void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1153fcf5ef2aSThomas Huth ppc_avr_t *c) 1154fcf5ef2aSThomas Huth { 1155fcf5ef2aSThomas Huth ppc_avr_t result; 1156fcf5ef2aSThomas Huth int i; 1157fcf5ef2aSThomas Huth 1158fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1159fcf5ef2aSThomas Huth int s = c->u8[i] & 0x1f; 1160fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1161fcf5ef2aSThomas Huth int index = s & 0xf; 1162fcf5ef2aSThomas Huth #else 1163fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1164fcf5ef2aSThomas Huth #endif 1165fcf5ef2aSThomas Huth 1166fcf5ef2aSThomas Huth if (s & 0x10) { 1167fcf5ef2aSThomas Huth result.u8[i] = b->u8[index]; 1168fcf5ef2aSThomas Huth } else { 1169fcf5ef2aSThomas Huth result.u8[i] = a->u8[index]; 1170fcf5ef2aSThomas Huth } 1171fcf5ef2aSThomas Huth } 1172fcf5ef2aSThomas Huth *r = result; 1173fcf5ef2aSThomas Huth } 1174fcf5ef2aSThomas Huth 1175fcf5ef2aSThomas Huth void helper_vpermr(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1176fcf5ef2aSThomas Huth ppc_avr_t *c) 1177fcf5ef2aSThomas Huth { 1178fcf5ef2aSThomas Huth ppc_avr_t result; 1179fcf5ef2aSThomas Huth int i; 1180fcf5ef2aSThomas Huth 1181fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1182fcf5ef2aSThomas Huth int s = c->u8[i] & 0x1f; 1183fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1184fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1185fcf5ef2aSThomas Huth #else 1186fcf5ef2aSThomas Huth int index = s & 0xf; 1187fcf5ef2aSThomas Huth #endif 1188fcf5ef2aSThomas Huth 1189fcf5ef2aSThomas Huth if (s & 0x10) { 1190fcf5ef2aSThomas Huth result.u8[i] = a->u8[index]; 1191fcf5ef2aSThomas Huth } else { 1192fcf5ef2aSThomas Huth result.u8[i] = b->u8[index]; 1193fcf5ef2aSThomas Huth } 1194fcf5ef2aSThomas Huth } 1195fcf5ef2aSThomas Huth *r = result; 1196fcf5ef2aSThomas Huth } 1197fcf5ef2aSThomas Huth 1198fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1199fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)]) 1200fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (i) 1201fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) != 0) 1202fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1)) 1203fcf5ef2aSThomas Huth #else 1204fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15-(i)]) 1205fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (1 - i) 1206fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) == 0) 1207fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) \ 1208fcf5ef2aSThomas Huth (extract64((avr)->u64[1 - i], 63 - index, 1)) 1209fcf5ef2aSThomas Huth #endif 1210fcf5ef2aSThomas Huth 1211fcf5ef2aSThomas Huth void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1212fcf5ef2aSThomas Huth { 1213fcf5ef2aSThomas Huth int i, j; 1214fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 1215fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1216fcf5ef2aSThomas Huth for (j = 0; j < 8; j++) { 1217fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, (i * 8) + j); 1218fcf5ef2aSThomas Huth if (index < 64 && EXTRACT_BIT(a, i, index)) { 1219fcf5ef2aSThomas Huth result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j); 1220fcf5ef2aSThomas Huth } 1221fcf5ef2aSThomas Huth } 1222fcf5ef2aSThomas Huth } 1223fcf5ef2aSThomas Huth *r = result; 1224fcf5ef2aSThomas Huth } 1225fcf5ef2aSThomas Huth 1226fcf5ef2aSThomas Huth void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1227fcf5ef2aSThomas Huth { 1228fcf5ef2aSThomas Huth int i; 1229fcf5ef2aSThomas Huth uint64_t perm = 0; 1230fcf5ef2aSThomas Huth 1231fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1232fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, i); 1233fcf5ef2aSThomas Huth 1234fcf5ef2aSThomas Huth if (index < 128) { 1235fcf5ef2aSThomas Huth uint64_t mask = (1ull << (63-(index & 0x3F))); 1236fcf5ef2aSThomas Huth if (a->u64[VBPERMQ_DW(index)] & mask) { 1237fcf5ef2aSThomas Huth perm |= (0x8000 >> i); 1238fcf5ef2aSThomas Huth } 1239fcf5ef2aSThomas Huth } 1240fcf5ef2aSThomas Huth } 1241fcf5ef2aSThomas Huth 1242fcf5ef2aSThomas Huth r->u64[HI_IDX] = perm; 1243fcf5ef2aSThomas Huth r->u64[LO_IDX] = 0; 1244fcf5ef2aSThomas Huth } 1245fcf5ef2aSThomas Huth 1246fcf5ef2aSThomas Huth #undef VBPERMQ_INDEX 1247fcf5ef2aSThomas Huth #undef VBPERMQ_DW 1248fcf5ef2aSThomas Huth 1249fcf5ef2aSThomas Huth static const uint64_t VGBBD_MASKS[256] = { 1250fcf5ef2aSThomas Huth 0x0000000000000000ull, /* 00 */ 1251fcf5ef2aSThomas Huth 0x0000000000000080ull, /* 01 */ 1252fcf5ef2aSThomas Huth 0x0000000000008000ull, /* 02 */ 1253fcf5ef2aSThomas Huth 0x0000000000008080ull, /* 03 */ 1254fcf5ef2aSThomas Huth 0x0000000000800000ull, /* 04 */ 1255fcf5ef2aSThomas Huth 0x0000000000800080ull, /* 05 */ 1256fcf5ef2aSThomas Huth 0x0000000000808000ull, /* 06 */ 1257fcf5ef2aSThomas Huth 0x0000000000808080ull, /* 07 */ 1258fcf5ef2aSThomas Huth 0x0000000080000000ull, /* 08 */ 1259fcf5ef2aSThomas Huth 0x0000000080000080ull, /* 09 */ 1260fcf5ef2aSThomas Huth 0x0000000080008000ull, /* 0A */ 1261fcf5ef2aSThomas Huth 0x0000000080008080ull, /* 0B */ 1262fcf5ef2aSThomas Huth 0x0000000080800000ull, /* 0C */ 1263fcf5ef2aSThomas Huth 0x0000000080800080ull, /* 0D */ 1264fcf5ef2aSThomas Huth 0x0000000080808000ull, /* 0E */ 1265fcf5ef2aSThomas Huth 0x0000000080808080ull, /* 0F */ 1266fcf5ef2aSThomas Huth 0x0000008000000000ull, /* 10 */ 1267fcf5ef2aSThomas Huth 0x0000008000000080ull, /* 11 */ 1268fcf5ef2aSThomas Huth 0x0000008000008000ull, /* 12 */ 1269fcf5ef2aSThomas Huth 0x0000008000008080ull, /* 13 */ 1270fcf5ef2aSThomas Huth 0x0000008000800000ull, /* 14 */ 1271fcf5ef2aSThomas Huth 0x0000008000800080ull, /* 15 */ 1272fcf5ef2aSThomas Huth 0x0000008000808000ull, /* 16 */ 1273fcf5ef2aSThomas Huth 0x0000008000808080ull, /* 17 */ 1274fcf5ef2aSThomas Huth 0x0000008080000000ull, /* 18 */ 1275fcf5ef2aSThomas Huth 0x0000008080000080ull, /* 19 */ 1276fcf5ef2aSThomas Huth 0x0000008080008000ull, /* 1A */ 1277fcf5ef2aSThomas Huth 0x0000008080008080ull, /* 1B */ 1278fcf5ef2aSThomas Huth 0x0000008080800000ull, /* 1C */ 1279fcf5ef2aSThomas Huth 0x0000008080800080ull, /* 1D */ 1280fcf5ef2aSThomas Huth 0x0000008080808000ull, /* 1E */ 1281fcf5ef2aSThomas Huth 0x0000008080808080ull, /* 1F */ 1282fcf5ef2aSThomas Huth 0x0000800000000000ull, /* 20 */ 1283fcf5ef2aSThomas Huth 0x0000800000000080ull, /* 21 */ 1284fcf5ef2aSThomas Huth 0x0000800000008000ull, /* 22 */ 1285fcf5ef2aSThomas Huth 0x0000800000008080ull, /* 23 */ 1286fcf5ef2aSThomas Huth 0x0000800000800000ull, /* 24 */ 1287fcf5ef2aSThomas Huth 0x0000800000800080ull, /* 25 */ 1288fcf5ef2aSThomas Huth 0x0000800000808000ull, /* 26 */ 1289fcf5ef2aSThomas Huth 0x0000800000808080ull, /* 27 */ 1290fcf5ef2aSThomas Huth 0x0000800080000000ull, /* 28 */ 1291fcf5ef2aSThomas Huth 0x0000800080000080ull, /* 29 */ 1292fcf5ef2aSThomas Huth 0x0000800080008000ull, /* 2A */ 1293fcf5ef2aSThomas Huth 0x0000800080008080ull, /* 2B */ 1294fcf5ef2aSThomas Huth 0x0000800080800000ull, /* 2C */ 1295fcf5ef2aSThomas Huth 0x0000800080800080ull, /* 2D */ 1296fcf5ef2aSThomas Huth 0x0000800080808000ull, /* 2E */ 1297fcf5ef2aSThomas Huth 0x0000800080808080ull, /* 2F */ 1298fcf5ef2aSThomas Huth 0x0000808000000000ull, /* 30 */ 1299fcf5ef2aSThomas Huth 0x0000808000000080ull, /* 31 */ 1300fcf5ef2aSThomas Huth 0x0000808000008000ull, /* 32 */ 1301fcf5ef2aSThomas Huth 0x0000808000008080ull, /* 33 */ 1302fcf5ef2aSThomas Huth 0x0000808000800000ull, /* 34 */ 1303fcf5ef2aSThomas Huth 0x0000808000800080ull, /* 35 */ 1304fcf5ef2aSThomas Huth 0x0000808000808000ull, /* 36 */ 1305fcf5ef2aSThomas Huth 0x0000808000808080ull, /* 37 */ 1306fcf5ef2aSThomas Huth 0x0000808080000000ull, /* 38 */ 1307fcf5ef2aSThomas Huth 0x0000808080000080ull, /* 39 */ 1308fcf5ef2aSThomas Huth 0x0000808080008000ull, /* 3A */ 1309fcf5ef2aSThomas Huth 0x0000808080008080ull, /* 3B */ 1310fcf5ef2aSThomas Huth 0x0000808080800000ull, /* 3C */ 1311fcf5ef2aSThomas Huth 0x0000808080800080ull, /* 3D */ 1312fcf5ef2aSThomas Huth 0x0000808080808000ull, /* 3E */ 1313fcf5ef2aSThomas Huth 0x0000808080808080ull, /* 3F */ 1314fcf5ef2aSThomas Huth 0x0080000000000000ull, /* 40 */ 1315fcf5ef2aSThomas Huth 0x0080000000000080ull, /* 41 */ 1316fcf5ef2aSThomas Huth 0x0080000000008000ull, /* 42 */ 1317fcf5ef2aSThomas Huth 0x0080000000008080ull, /* 43 */ 1318fcf5ef2aSThomas Huth 0x0080000000800000ull, /* 44 */ 1319fcf5ef2aSThomas Huth 0x0080000000800080ull, /* 45 */ 1320fcf5ef2aSThomas Huth 0x0080000000808000ull, /* 46 */ 1321fcf5ef2aSThomas Huth 0x0080000000808080ull, /* 47 */ 1322fcf5ef2aSThomas Huth 0x0080000080000000ull, /* 48 */ 1323fcf5ef2aSThomas Huth 0x0080000080000080ull, /* 49 */ 1324fcf5ef2aSThomas Huth 0x0080000080008000ull, /* 4A */ 1325fcf5ef2aSThomas Huth 0x0080000080008080ull, /* 4B */ 1326fcf5ef2aSThomas Huth 0x0080000080800000ull, /* 4C */ 1327fcf5ef2aSThomas Huth 0x0080000080800080ull, /* 4D */ 1328fcf5ef2aSThomas Huth 0x0080000080808000ull, /* 4E */ 1329fcf5ef2aSThomas Huth 0x0080000080808080ull, /* 4F */ 1330fcf5ef2aSThomas Huth 0x0080008000000000ull, /* 50 */ 1331fcf5ef2aSThomas Huth 0x0080008000000080ull, /* 51 */ 1332fcf5ef2aSThomas Huth 0x0080008000008000ull, /* 52 */ 1333fcf5ef2aSThomas Huth 0x0080008000008080ull, /* 53 */ 1334fcf5ef2aSThomas Huth 0x0080008000800000ull, /* 54 */ 1335fcf5ef2aSThomas Huth 0x0080008000800080ull, /* 55 */ 1336fcf5ef2aSThomas Huth 0x0080008000808000ull, /* 56 */ 1337fcf5ef2aSThomas Huth 0x0080008000808080ull, /* 57 */ 1338fcf5ef2aSThomas Huth 0x0080008080000000ull, /* 58 */ 1339fcf5ef2aSThomas Huth 0x0080008080000080ull, /* 59 */ 1340fcf5ef2aSThomas Huth 0x0080008080008000ull, /* 5A */ 1341fcf5ef2aSThomas Huth 0x0080008080008080ull, /* 5B */ 1342fcf5ef2aSThomas Huth 0x0080008080800000ull, /* 5C */ 1343fcf5ef2aSThomas Huth 0x0080008080800080ull, /* 5D */ 1344fcf5ef2aSThomas Huth 0x0080008080808000ull, /* 5E */ 1345fcf5ef2aSThomas Huth 0x0080008080808080ull, /* 5F */ 1346fcf5ef2aSThomas Huth 0x0080800000000000ull, /* 60 */ 1347fcf5ef2aSThomas Huth 0x0080800000000080ull, /* 61 */ 1348fcf5ef2aSThomas Huth 0x0080800000008000ull, /* 62 */ 1349fcf5ef2aSThomas Huth 0x0080800000008080ull, /* 63 */ 1350fcf5ef2aSThomas Huth 0x0080800000800000ull, /* 64 */ 1351fcf5ef2aSThomas Huth 0x0080800000800080ull, /* 65 */ 1352fcf5ef2aSThomas Huth 0x0080800000808000ull, /* 66 */ 1353fcf5ef2aSThomas Huth 0x0080800000808080ull, /* 67 */ 1354fcf5ef2aSThomas Huth 0x0080800080000000ull, /* 68 */ 1355fcf5ef2aSThomas Huth 0x0080800080000080ull, /* 69 */ 1356fcf5ef2aSThomas Huth 0x0080800080008000ull, /* 6A */ 1357fcf5ef2aSThomas Huth 0x0080800080008080ull, /* 6B */ 1358fcf5ef2aSThomas Huth 0x0080800080800000ull, /* 6C */ 1359fcf5ef2aSThomas Huth 0x0080800080800080ull, /* 6D */ 1360fcf5ef2aSThomas Huth 0x0080800080808000ull, /* 6E */ 1361fcf5ef2aSThomas Huth 0x0080800080808080ull, /* 6F */ 1362fcf5ef2aSThomas Huth 0x0080808000000000ull, /* 70 */ 1363fcf5ef2aSThomas Huth 0x0080808000000080ull, /* 71 */ 1364fcf5ef2aSThomas Huth 0x0080808000008000ull, /* 72 */ 1365fcf5ef2aSThomas Huth 0x0080808000008080ull, /* 73 */ 1366fcf5ef2aSThomas Huth 0x0080808000800000ull, /* 74 */ 1367fcf5ef2aSThomas Huth 0x0080808000800080ull, /* 75 */ 1368fcf5ef2aSThomas Huth 0x0080808000808000ull, /* 76 */ 1369fcf5ef2aSThomas Huth 0x0080808000808080ull, /* 77 */ 1370fcf5ef2aSThomas Huth 0x0080808080000000ull, /* 78 */ 1371fcf5ef2aSThomas Huth 0x0080808080000080ull, /* 79 */ 1372fcf5ef2aSThomas Huth 0x0080808080008000ull, /* 7A */ 1373fcf5ef2aSThomas Huth 0x0080808080008080ull, /* 7B */ 1374fcf5ef2aSThomas Huth 0x0080808080800000ull, /* 7C */ 1375fcf5ef2aSThomas Huth 0x0080808080800080ull, /* 7D */ 1376fcf5ef2aSThomas Huth 0x0080808080808000ull, /* 7E */ 1377fcf5ef2aSThomas Huth 0x0080808080808080ull, /* 7F */ 1378fcf5ef2aSThomas Huth 0x8000000000000000ull, /* 80 */ 1379fcf5ef2aSThomas Huth 0x8000000000000080ull, /* 81 */ 1380fcf5ef2aSThomas Huth 0x8000000000008000ull, /* 82 */ 1381fcf5ef2aSThomas Huth 0x8000000000008080ull, /* 83 */ 1382fcf5ef2aSThomas Huth 0x8000000000800000ull, /* 84 */ 1383fcf5ef2aSThomas Huth 0x8000000000800080ull, /* 85 */ 1384fcf5ef2aSThomas Huth 0x8000000000808000ull, /* 86 */ 1385fcf5ef2aSThomas Huth 0x8000000000808080ull, /* 87 */ 1386fcf5ef2aSThomas Huth 0x8000000080000000ull, /* 88 */ 1387fcf5ef2aSThomas Huth 0x8000000080000080ull, /* 89 */ 1388fcf5ef2aSThomas Huth 0x8000000080008000ull, /* 8A */ 1389fcf5ef2aSThomas Huth 0x8000000080008080ull, /* 8B */ 1390fcf5ef2aSThomas Huth 0x8000000080800000ull, /* 8C */ 1391fcf5ef2aSThomas Huth 0x8000000080800080ull, /* 8D */ 1392fcf5ef2aSThomas Huth 0x8000000080808000ull, /* 8E */ 1393fcf5ef2aSThomas Huth 0x8000000080808080ull, /* 8F */ 1394fcf5ef2aSThomas Huth 0x8000008000000000ull, /* 90 */ 1395fcf5ef2aSThomas Huth 0x8000008000000080ull, /* 91 */ 1396fcf5ef2aSThomas Huth 0x8000008000008000ull, /* 92 */ 1397fcf5ef2aSThomas Huth 0x8000008000008080ull, /* 93 */ 1398fcf5ef2aSThomas Huth 0x8000008000800000ull, /* 94 */ 1399fcf5ef2aSThomas Huth 0x8000008000800080ull, /* 95 */ 1400fcf5ef2aSThomas Huth 0x8000008000808000ull, /* 96 */ 1401fcf5ef2aSThomas Huth 0x8000008000808080ull, /* 97 */ 1402fcf5ef2aSThomas Huth 0x8000008080000000ull, /* 98 */ 1403fcf5ef2aSThomas Huth 0x8000008080000080ull, /* 99 */ 1404fcf5ef2aSThomas Huth 0x8000008080008000ull, /* 9A */ 1405fcf5ef2aSThomas Huth 0x8000008080008080ull, /* 9B */ 1406fcf5ef2aSThomas Huth 0x8000008080800000ull, /* 9C */ 1407fcf5ef2aSThomas Huth 0x8000008080800080ull, /* 9D */ 1408fcf5ef2aSThomas Huth 0x8000008080808000ull, /* 9E */ 1409fcf5ef2aSThomas Huth 0x8000008080808080ull, /* 9F */ 1410fcf5ef2aSThomas Huth 0x8000800000000000ull, /* A0 */ 1411fcf5ef2aSThomas Huth 0x8000800000000080ull, /* A1 */ 1412fcf5ef2aSThomas Huth 0x8000800000008000ull, /* A2 */ 1413fcf5ef2aSThomas Huth 0x8000800000008080ull, /* A3 */ 1414fcf5ef2aSThomas Huth 0x8000800000800000ull, /* A4 */ 1415fcf5ef2aSThomas Huth 0x8000800000800080ull, /* A5 */ 1416fcf5ef2aSThomas Huth 0x8000800000808000ull, /* A6 */ 1417fcf5ef2aSThomas Huth 0x8000800000808080ull, /* A7 */ 1418fcf5ef2aSThomas Huth 0x8000800080000000ull, /* A8 */ 1419fcf5ef2aSThomas Huth 0x8000800080000080ull, /* A9 */ 1420fcf5ef2aSThomas Huth 0x8000800080008000ull, /* AA */ 1421fcf5ef2aSThomas Huth 0x8000800080008080ull, /* AB */ 1422fcf5ef2aSThomas Huth 0x8000800080800000ull, /* AC */ 1423fcf5ef2aSThomas Huth 0x8000800080800080ull, /* AD */ 1424fcf5ef2aSThomas Huth 0x8000800080808000ull, /* AE */ 1425fcf5ef2aSThomas Huth 0x8000800080808080ull, /* AF */ 1426fcf5ef2aSThomas Huth 0x8000808000000000ull, /* B0 */ 1427fcf5ef2aSThomas Huth 0x8000808000000080ull, /* B1 */ 1428fcf5ef2aSThomas Huth 0x8000808000008000ull, /* B2 */ 1429fcf5ef2aSThomas Huth 0x8000808000008080ull, /* B3 */ 1430fcf5ef2aSThomas Huth 0x8000808000800000ull, /* B4 */ 1431fcf5ef2aSThomas Huth 0x8000808000800080ull, /* B5 */ 1432fcf5ef2aSThomas Huth 0x8000808000808000ull, /* B6 */ 1433fcf5ef2aSThomas Huth 0x8000808000808080ull, /* B7 */ 1434fcf5ef2aSThomas Huth 0x8000808080000000ull, /* B8 */ 1435fcf5ef2aSThomas Huth 0x8000808080000080ull, /* B9 */ 1436fcf5ef2aSThomas Huth 0x8000808080008000ull, /* BA */ 1437fcf5ef2aSThomas Huth 0x8000808080008080ull, /* BB */ 1438fcf5ef2aSThomas Huth 0x8000808080800000ull, /* BC */ 1439fcf5ef2aSThomas Huth 0x8000808080800080ull, /* BD */ 1440fcf5ef2aSThomas Huth 0x8000808080808000ull, /* BE */ 1441fcf5ef2aSThomas Huth 0x8000808080808080ull, /* BF */ 1442fcf5ef2aSThomas Huth 0x8080000000000000ull, /* C0 */ 1443fcf5ef2aSThomas Huth 0x8080000000000080ull, /* C1 */ 1444fcf5ef2aSThomas Huth 0x8080000000008000ull, /* C2 */ 1445fcf5ef2aSThomas Huth 0x8080000000008080ull, /* C3 */ 1446fcf5ef2aSThomas Huth 0x8080000000800000ull, /* C4 */ 1447fcf5ef2aSThomas Huth 0x8080000000800080ull, /* C5 */ 1448fcf5ef2aSThomas Huth 0x8080000000808000ull, /* C6 */ 1449fcf5ef2aSThomas Huth 0x8080000000808080ull, /* C7 */ 1450fcf5ef2aSThomas Huth 0x8080000080000000ull, /* C8 */ 1451fcf5ef2aSThomas Huth 0x8080000080000080ull, /* C9 */ 1452fcf5ef2aSThomas Huth 0x8080000080008000ull, /* CA */ 1453fcf5ef2aSThomas Huth 0x8080000080008080ull, /* CB */ 1454fcf5ef2aSThomas Huth 0x8080000080800000ull, /* CC */ 1455fcf5ef2aSThomas Huth 0x8080000080800080ull, /* CD */ 1456fcf5ef2aSThomas Huth 0x8080000080808000ull, /* CE */ 1457fcf5ef2aSThomas Huth 0x8080000080808080ull, /* CF */ 1458fcf5ef2aSThomas Huth 0x8080008000000000ull, /* D0 */ 1459fcf5ef2aSThomas Huth 0x8080008000000080ull, /* D1 */ 1460fcf5ef2aSThomas Huth 0x8080008000008000ull, /* D2 */ 1461fcf5ef2aSThomas Huth 0x8080008000008080ull, /* D3 */ 1462fcf5ef2aSThomas Huth 0x8080008000800000ull, /* D4 */ 1463fcf5ef2aSThomas Huth 0x8080008000800080ull, /* D5 */ 1464fcf5ef2aSThomas Huth 0x8080008000808000ull, /* D6 */ 1465fcf5ef2aSThomas Huth 0x8080008000808080ull, /* D7 */ 1466fcf5ef2aSThomas Huth 0x8080008080000000ull, /* D8 */ 1467fcf5ef2aSThomas Huth 0x8080008080000080ull, /* D9 */ 1468fcf5ef2aSThomas Huth 0x8080008080008000ull, /* DA */ 1469fcf5ef2aSThomas Huth 0x8080008080008080ull, /* DB */ 1470fcf5ef2aSThomas Huth 0x8080008080800000ull, /* DC */ 1471fcf5ef2aSThomas Huth 0x8080008080800080ull, /* DD */ 1472fcf5ef2aSThomas Huth 0x8080008080808000ull, /* DE */ 1473fcf5ef2aSThomas Huth 0x8080008080808080ull, /* DF */ 1474fcf5ef2aSThomas Huth 0x8080800000000000ull, /* E0 */ 1475fcf5ef2aSThomas Huth 0x8080800000000080ull, /* E1 */ 1476fcf5ef2aSThomas Huth 0x8080800000008000ull, /* E2 */ 1477fcf5ef2aSThomas Huth 0x8080800000008080ull, /* E3 */ 1478fcf5ef2aSThomas Huth 0x8080800000800000ull, /* E4 */ 1479fcf5ef2aSThomas Huth 0x8080800000800080ull, /* E5 */ 1480fcf5ef2aSThomas Huth 0x8080800000808000ull, /* E6 */ 1481fcf5ef2aSThomas Huth 0x8080800000808080ull, /* E7 */ 1482fcf5ef2aSThomas Huth 0x8080800080000000ull, /* E8 */ 1483fcf5ef2aSThomas Huth 0x8080800080000080ull, /* E9 */ 1484fcf5ef2aSThomas Huth 0x8080800080008000ull, /* EA */ 1485fcf5ef2aSThomas Huth 0x8080800080008080ull, /* EB */ 1486fcf5ef2aSThomas Huth 0x8080800080800000ull, /* EC */ 1487fcf5ef2aSThomas Huth 0x8080800080800080ull, /* ED */ 1488fcf5ef2aSThomas Huth 0x8080800080808000ull, /* EE */ 1489fcf5ef2aSThomas Huth 0x8080800080808080ull, /* EF */ 1490fcf5ef2aSThomas Huth 0x8080808000000000ull, /* F0 */ 1491fcf5ef2aSThomas Huth 0x8080808000000080ull, /* F1 */ 1492fcf5ef2aSThomas Huth 0x8080808000008000ull, /* F2 */ 1493fcf5ef2aSThomas Huth 0x8080808000008080ull, /* F3 */ 1494fcf5ef2aSThomas Huth 0x8080808000800000ull, /* F4 */ 1495fcf5ef2aSThomas Huth 0x8080808000800080ull, /* F5 */ 1496fcf5ef2aSThomas Huth 0x8080808000808000ull, /* F6 */ 1497fcf5ef2aSThomas Huth 0x8080808000808080ull, /* F7 */ 1498fcf5ef2aSThomas Huth 0x8080808080000000ull, /* F8 */ 1499fcf5ef2aSThomas Huth 0x8080808080000080ull, /* F9 */ 1500fcf5ef2aSThomas Huth 0x8080808080008000ull, /* FA */ 1501fcf5ef2aSThomas Huth 0x8080808080008080ull, /* FB */ 1502fcf5ef2aSThomas Huth 0x8080808080800000ull, /* FC */ 1503fcf5ef2aSThomas Huth 0x8080808080800080ull, /* FD */ 1504fcf5ef2aSThomas Huth 0x8080808080808000ull, /* FE */ 1505fcf5ef2aSThomas Huth 0x8080808080808080ull, /* FF */ 1506fcf5ef2aSThomas Huth }; 1507fcf5ef2aSThomas Huth 1508fcf5ef2aSThomas Huth void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b) 1509fcf5ef2aSThomas Huth { 1510fcf5ef2aSThomas Huth int i; 1511fcf5ef2aSThomas Huth uint64_t t[2] = { 0, 0 }; 1512fcf5ef2aSThomas Huth 1513fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1514fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1515fcf5ef2aSThomas Huth t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7); 1516fcf5ef2aSThomas Huth #else 1517fcf5ef2aSThomas Huth t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (7-(i & 7)); 1518fcf5ef2aSThomas Huth #endif 1519fcf5ef2aSThomas Huth } 1520fcf5ef2aSThomas Huth 1521fcf5ef2aSThomas Huth r->u64[0] = t[0]; 1522fcf5ef2aSThomas Huth r->u64[1] = t[1]; 1523fcf5ef2aSThomas Huth } 1524fcf5ef2aSThomas Huth 1525fcf5ef2aSThomas Huth #define PMSUM(name, srcfld, trgfld, trgtyp) \ 1526fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1527fcf5ef2aSThomas Huth { \ 1528fcf5ef2aSThomas Huth int i, j; \ 1529fcf5ef2aSThomas Huth trgtyp prod[sizeof(ppc_avr_t)/sizeof(a->srcfld[0])]; \ 1530fcf5ef2aSThomas Huth \ 1531fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, srcfld) { \ 1532fcf5ef2aSThomas Huth prod[i] = 0; \ 1533fcf5ef2aSThomas Huth for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \ 1534fcf5ef2aSThomas Huth if (a->srcfld[i] & (1ull<<j)) { \ 1535fcf5ef2aSThomas Huth prod[i] ^= ((trgtyp)b->srcfld[i] << j); \ 1536fcf5ef2aSThomas Huth } \ 1537fcf5ef2aSThomas Huth } \ 1538fcf5ef2aSThomas Huth } \ 1539fcf5ef2aSThomas Huth \ 1540fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, trgfld) { \ 1541fcf5ef2aSThomas Huth r->trgfld[i] = prod[2*i] ^ prod[2*i+1]; \ 1542fcf5ef2aSThomas Huth } \ 1543fcf5ef2aSThomas Huth } 1544fcf5ef2aSThomas Huth 1545fcf5ef2aSThomas Huth PMSUM(vpmsumb, u8, u16, uint16_t) 1546fcf5ef2aSThomas Huth PMSUM(vpmsumh, u16, u32, uint32_t) 1547fcf5ef2aSThomas Huth PMSUM(vpmsumw, u32, u64, uint64_t) 1548fcf5ef2aSThomas Huth 1549fcf5ef2aSThomas Huth void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1550fcf5ef2aSThomas Huth { 1551fcf5ef2aSThomas Huth 1552fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1553fcf5ef2aSThomas Huth int i, j; 1554fcf5ef2aSThomas Huth __uint128_t prod[2]; 1555fcf5ef2aSThomas Huth 1556fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1557fcf5ef2aSThomas Huth prod[i] = 0; 1558fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1559fcf5ef2aSThomas Huth if (a->u64[i] & (1ull<<j)) { 1560fcf5ef2aSThomas Huth prod[i] ^= (((__uint128_t)b->u64[i]) << j); 1561fcf5ef2aSThomas Huth } 1562fcf5ef2aSThomas Huth } 1563fcf5ef2aSThomas Huth } 1564fcf5ef2aSThomas Huth 1565fcf5ef2aSThomas Huth r->u128 = prod[0] ^ prod[1]; 1566fcf5ef2aSThomas Huth 1567fcf5ef2aSThomas Huth #else 1568fcf5ef2aSThomas Huth int i, j; 1569fcf5ef2aSThomas Huth ppc_avr_t prod[2]; 1570fcf5ef2aSThomas Huth 1571fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1572fcf5ef2aSThomas Huth prod[i].u64[LO_IDX] = prod[i].u64[HI_IDX] = 0; 1573fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1574fcf5ef2aSThomas Huth if (a->u64[i] & (1ull<<j)) { 1575fcf5ef2aSThomas Huth ppc_avr_t bshift; 1576fcf5ef2aSThomas Huth if (j == 0) { 1577fcf5ef2aSThomas Huth bshift.u64[HI_IDX] = 0; 1578fcf5ef2aSThomas Huth bshift.u64[LO_IDX] = b->u64[i]; 1579fcf5ef2aSThomas Huth } else { 1580fcf5ef2aSThomas Huth bshift.u64[HI_IDX] = b->u64[i] >> (64-j); 1581fcf5ef2aSThomas Huth bshift.u64[LO_IDX] = b->u64[i] << j; 1582fcf5ef2aSThomas Huth } 1583fcf5ef2aSThomas Huth prod[i].u64[LO_IDX] ^= bshift.u64[LO_IDX]; 1584fcf5ef2aSThomas Huth prod[i].u64[HI_IDX] ^= bshift.u64[HI_IDX]; 1585fcf5ef2aSThomas Huth } 1586fcf5ef2aSThomas Huth } 1587fcf5ef2aSThomas Huth } 1588fcf5ef2aSThomas Huth 1589fcf5ef2aSThomas Huth r->u64[LO_IDX] = prod[0].u64[LO_IDX] ^ prod[1].u64[LO_IDX]; 1590fcf5ef2aSThomas Huth r->u64[HI_IDX] = prod[0].u64[HI_IDX] ^ prod[1].u64[HI_IDX]; 1591fcf5ef2aSThomas Huth #endif 1592fcf5ef2aSThomas Huth } 1593fcf5ef2aSThomas Huth 1594fcf5ef2aSThomas Huth 1595fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1596fcf5ef2aSThomas Huth #define PKBIG 1 1597fcf5ef2aSThomas Huth #else 1598fcf5ef2aSThomas Huth #define PKBIG 0 1599fcf5ef2aSThomas Huth #endif 1600fcf5ef2aSThomas Huth void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1601fcf5ef2aSThomas Huth { 1602fcf5ef2aSThomas Huth int i, j; 1603fcf5ef2aSThomas Huth ppc_avr_t result; 1604fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1605fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { a, b }; 1606fcf5ef2aSThomas Huth #else 1607fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { b, a }; 1608fcf5ef2aSThomas Huth #endif 1609fcf5ef2aSThomas Huth 1610fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1611fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(j, u32) { 1612fcf5ef2aSThomas Huth uint32_t e = x[i]->u32[j]; 1613fcf5ef2aSThomas Huth 1614fcf5ef2aSThomas Huth result.u16[4*i+j] = (((e >> 9) & 0xfc00) | 1615fcf5ef2aSThomas Huth ((e >> 6) & 0x3e0) | 1616fcf5ef2aSThomas Huth ((e >> 3) & 0x1f)); 1617fcf5ef2aSThomas Huth } 1618fcf5ef2aSThomas Huth } 1619fcf5ef2aSThomas Huth *r = result; 1620fcf5ef2aSThomas Huth } 1621fcf5ef2aSThomas Huth 1622fcf5ef2aSThomas Huth #define VPK(suffix, from, to, cvt, dosat) \ 1623fcf5ef2aSThomas Huth void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1624fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 1625fcf5ef2aSThomas Huth { \ 1626fcf5ef2aSThomas Huth int i; \ 1627fcf5ef2aSThomas Huth int sat = 0; \ 1628fcf5ef2aSThomas Huth ppc_avr_t result; \ 1629fcf5ef2aSThomas Huth ppc_avr_t *a0 = PKBIG ? a : b; \ 1630fcf5ef2aSThomas Huth ppc_avr_t *a1 = PKBIG ? b : a; \ 1631fcf5ef2aSThomas Huth \ 1632fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, from) { \ 1633fcf5ef2aSThomas Huth result.to[i] = cvt(a0->from[i], &sat); \ 1634fcf5ef2aSThomas Huth result.to[i+ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat); \ 1635fcf5ef2aSThomas Huth } \ 1636fcf5ef2aSThomas Huth *r = result; \ 1637fcf5ef2aSThomas Huth if (dosat && sat) { \ 1638fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); \ 1639fcf5ef2aSThomas Huth } \ 1640fcf5ef2aSThomas Huth } 1641fcf5ef2aSThomas Huth #define I(x, y) (x) 1642fcf5ef2aSThomas Huth VPK(shss, s16, s8, cvtshsb, 1) 1643fcf5ef2aSThomas Huth VPK(shus, s16, u8, cvtshub, 1) 1644fcf5ef2aSThomas Huth VPK(swss, s32, s16, cvtswsh, 1) 1645fcf5ef2aSThomas Huth VPK(swus, s32, u16, cvtswuh, 1) 1646fcf5ef2aSThomas Huth VPK(sdss, s64, s32, cvtsdsw, 1) 1647fcf5ef2aSThomas Huth VPK(sdus, s64, u32, cvtsduw, 1) 1648fcf5ef2aSThomas Huth VPK(uhus, u16, u8, cvtuhub, 1) 1649fcf5ef2aSThomas Huth VPK(uwus, u32, u16, cvtuwuh, 1) 1650fcf5ef2aSThomas Huth VPK(udus, u64, u32, cvtuduw, 1) 1651fcf5ef2aSThomas Huth VPK(uhum, u16, u8, I, 0) 1652fcf5ef2aSThomas Huth VPK(uwum, u32, u16, I, 0) 1653fcf5ef2aSThomas Huth VPK(udum, u64, u32, I, 0) 1654fcf5ef2aSThomas Huth #undef I 1655fcf5ef2aSThomas Huth #undef VPK 1656fcf5ef2aSThomas Huth #undef PKBIG 1657fcf5ef2aSThomas Huth 1658fcf5ef2aSThomas Huth void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1659fcf5ef2aSThomas Huth { 1660fcf5ef2aSThomas Huth int i; 1661fcf5ef2aSThomas Huth 166205ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 166305ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status); 1664fcf5ef2aSThomas Huth } 1665fcf5ef2aSThomas Huth } 1666fcf5ef2aSThomas Huth 1667fcf5ef2aSThomas Huth #define VRFI(suffix, rounding) \ 1668fcf5ef2aSThomas Huth void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1669fcf5ef2aSThomas Huth ppc_avr_t *b) \ 1670fcf5ef2aSThomas Huth { \ 1671fcf5ef2aSThomas Huth int i; \ 1672fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 1673fcf5ef2aSThomas Huth \ 1674fcf5ef2aSThomas Huth set_float_rounding_mode(rounding, &s); \ 167505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 167605ee3e8aSMark Cave-Ayland r->f32[i] = float32_round_to_int (b->f32[i], &s); \ 1677fcf5ef2aSThomas Huth } \ 1678fcf5ef2aSThomas Huth } 1679fcf5ef2aSThomas Huth VRFI(n, float_round_nearest_even) 1680fcf5ef2aSThomas Huth VRFI(m, float_round_down) 1681fcf5ef2aSThomas Huth VRFI(p, float_round_up) 1682fcf5ef2aSThomas Huth VRFI(z, float_round_to_zero) 1683fcf5ef2aSThomas Huth #undef VRFI 1684fcf5ef2aSThomas Huth 1685fcf5ef2aSThomas Huth #define VROTATE(suffix, element, mask) \ 1686fcf5ef2aSThomas Huth void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1687fcf5ef2aSThomas Huth { \ 1688fcf5ef2aSThomas Huth int i; \ 1689fcf5ef2aSThomas Huth \ 1690fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1691fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1692fcf5ef2aSThomas Huth r->element[i] = (a->element[i] << shift) | \ 1693fcf5ef2aSThomas Huth (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \ 1694fcf5ef2aSThomas Huth } \ 1695fcf5ef2aSThomas Huth } 1696fcf5ef2aSThomas Huth VROTATE(b, u8, 0x7) 1697fcf5ef2aSThomas Huth VROTATE(h, u16, 0xF) 1698fcf5ef2aSThomas Huth VROTATE(w, u32, 0x1F) 1699fcf5ef2aSThomas Huth VROTATE(d, u64, 0x3F) 1700fcf5ef2aSThomas Huth #undef VROTATE 1701fcf5ef2aSThomas Huth 1702fcf5ef2aSThomas Huth void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1703fcf5ef2aSThomas Huth { 1704fcf5ef2aSThomas Huth int i; 1705fcf5ef2aSThomas Huth 170605ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 170705ee3e8aSMark Cave-Ayland float32 t = float32_sqrt(b->f32[i], &env->vec_status); 1708fcf5ef2aSThomas Huth 170905ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, t, &env->vec_status); 1710fcf5ef2aSThomas Huth } 1711fcf5ef2aSThomas Huth } 1712fcf5ef2aSThomas Huth 1713fcf5ef2aSThomas Huth #define VRLMI(name, size, element, insert) \ 1714fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1715fcf5ef2aSThomas Huth { \ 1716fcf5ef2aSThomas Huth int i; \ 1717fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1718fcf5ef2aSThomas Huth uint##size##_t src1 = a->element[i]; \ 1719fcf5ef2aSThomas Huth uint##size##_t src2 = b->element[i]; \ 1720fcf5ef2aSThomas Huth uint##size##_t src3 = r->element[i]; \ 1721fcf5ef2aSThomas Huth uint##size##_t begin, end, shift, mask, rot_val; \ 1722fcf5ef2aSThomas Huth \ 1723fcf5ef2aSThomas Huth shift = extract##size(src2, 0, 6); \ 1724fcf5ef2aSThomas Huth end = extract##size(src2, 8, 6); \ 1725fcf5ef2aSThomas Huth begin = extract##size(src2, 16, 6); \ 1726fcf5ef2aSThomas Huth rot_val = rol##size(src1, shift); \ 1727fcf5ef2aSThomas Huth mask = mask_u##size(begin, end); \ 1728fcf5ef2aSThomas Huth if (insert) { \ 1729fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask) | (src3 & ~mask); \ 1730fcf5ef2aSThomas Huth } else { \ 1731fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask); \ 1732fcf5ef2aSThomas Huth } \ 1733fcf5ef2aSThomas Huth } \ 1734fcf5ef2aSThomas Huth } 1735fcf5ef2aSThomas Huth 1736fcf5ef2aSThomas Huth VRLMI(vrldmi, 64, u64, 1); 1737fcf5ef2aSThomas Huth VRLMI(vrlwmi, 32, u32, 1); 1738fcf5ef2aSThomas Huth VRLMI(vrldnm, 64, u64, 0); 1739fcf5ef2aSThomas Huth VRLMI(vrlwnm, 32, u32, 0); 1740fcf5ef2aSThomas Huth 1741fcf5ef2aSThomas Huth void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1742fcf5ef2aSThomas Huth ppc_avr_t *c) 1743fcf5ef2aSThomas Huth { 1744fcf5ef2aSThomas Huth r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]); 1745fcf5ef2aSThomas Huth r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]); 1746fcf5ef2aSThomas Huth } 1747fcf5ef2aSThomas Huth 1748fcf5ef2aSThomas Huth void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1749fcf5ef2aSThomas Huth { 1750fcf5ef2aSThomas Huth int i; 1751fcf5ef2aSThomas Huth 175205ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 175305ee3e8aSMark Cave-Ayland r->f32[i] = float32_exp2(b->f32[i], &env->vec_status); 1754fcf5ef2aSThomas Huth } 1755fcf5ef2aSThomas Huth } 1756fcf5ef2aSThomas Huth 1757fcf5ef2aSThomas Huth void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1758fcf5ef2aSThomas Huth { 1759fcf5ef2aSThomas Huth int i; 1760fcf5ef2aSThomas Huth 176105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 176205ee3e8aSMark Cave-Ayland r->f32[i] = float32_log2(b->f32[i], &env->vec_status); 1763fcf5ef2aSThomas Huth } 1764fcf5ef2aSThomas Huth } 1765fcf5ef2aSThomas Huth 176660caf221SAvinesh Kumar #if defined(HOST_WORDS_BIGENDIAN) 176760caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 176860caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 176960caf221SAvinesh Kumar { \ 177060caf221SAvinesh Kumar int index; \ 177160caf221SAvinesh Kumar if (left) { \ 177260caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 177360caf221SAvinesh Kumar } else { \ 177460caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 177560caf221SAvinesh Kumar } \ 177660caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 177760caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 177860caf221SAvinesh Kumar } 177960caf221SAvinesh Kumar #else 178060caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 178160caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 178260caf221SAvinesh Kumar { \ 178360caf221SAvinesh Kumar int index; \ 178460caf221SAvinesh Kumar if (left) { \ 178560caf221SAvinesh Kumar index = ((15 - (a & 0xf) + 1) * 8) - size; \ 178660caf221SAvinesh Kumar } else { \ 178760caf221SAvinesh Kumar index = (a & 0xf) * 8; \ 178860caf221SAvinesh Kumar } \ 178960caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 179060caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 179160caf221SAvinesh Kumar } 179260caf221SAvinesh Kumar #endif 179360caf221SAvinesh Kumar 179460caf221SAvinesh Kumar VEXTU_X_DO(vextublx, 8, 1) 179560caf221SAvinesh Kumar VEXTU_X_DO(vextuhlx, 16, 1) 179660caf221SAvinesh Kumar VEXTU_X_DO(vextuwlx, 32, 1) 179760caf221SAvinesh Kumar VEXTU_X_DO(vextubrx, 8, 0) 179860caf221SAvinesh Kumar VEXTU_X_DO(vextuhrx, 16, 0) 179960caf221SAvinesh Kumar VEXTU_X_DO(vextuwrx, 32, 0) 180060caf221SAvinesh Kumar #undef VEXTU_X_DO 180160caf221SAvinesh Kumar 1802fcf5ef2aSThomas Huth /* The specification says that the results are undefined if all of the 1803fcf5ef2aSThomas Huth * shift counts are not identical. We check to make sure that they are 1804fcf5ef2aSThomas Huth * to conform to what real hardware appears to do. */ 1805fcf5ef2aSThomas Huth #define VSHIFT(suffix, leftp) \ 1806fcf5ef2aSThomas Huth void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1807fcf5ef2aSThomas Huth { \ 1808fcf5ef2aSThomas Huth int shift = b->u8[LO_IDX*15] & 0x7; \ 1809fcf5ef2aSThomas Huth int doit = 1; \ 1810fcf5ef2aSThomas Huth int i; \ 1811fcf5ef2aSThomas Huth \ 1812fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { \ 1813fcf5ef2aSThomas Huth doit = doit && ((b->u8[i] & 0x7) == shift); \ 1814fcf5ef2aSThomas Huth } \ 1815fcf5ef2aSThomas Huth if (doit) { \ 1816fcf5ef2aSThomas Huth if (shift == 0) { \ 1817fcf5ef2aSThomas Huth *r = *a; \ 1818fcf5ef2aSThomas Huth } else if (leftp) { \ 1819fcf5ef2aSThomas Huth uint64_t carry = a->u64[LO_IDX] >> (64 - shift); \ 1820fcf5ef2aSThomas Huth \ 1821fcf5ef2aSThomas Huth r->u64[HI_IDX] = (a->u64[HI_IDX] << shift) | carry; \ 1822fcf5ef2aSThomas Huth r->u64[LO_IDX] = a->u64[LO_IDX] << shift; \ 1823fcf5ef2aSThomas Huth } else { \ 1824fcf5ef2aSThomas Huth uint64_t carry = a->u64[HI_IDX] << (64 - shift); \ 1825fcf5ef2aSThomas Huth \ 1826fcf5ef2aSThomas Huth r->u64[LO_IDX] = (a->u64[LO_IDX] >> shift) | carry; \ 1827fcf5ef2aSThomas Huth r->u64[HI_IDX] = a->u64[HI_IDX] >> shift; \ 1828fcf5ef2aSThomas Huth } \ 1829fcf5ef2aSThomas Huth } \ 1830fcf5ef2aSThomas Huth } 1831fcf5ef2aSThomas Huth VSHIFT(l, 1) 1832fcf5ef2aSThomas Huth VSHIFT(r, 0) 1833fcf5ef2aSThomas Huth #undef VSHIFT 1834fcf5ef2aSThomas Huth 1835fcf5ef2aSThomas Huth #define VSL(suffix, element, mask) \ 1836fcf5ef2aSThomas Huth void helper_vsl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1837fcf5ef2aSThomas Huth { \ 1838fcf5ef2aSThomas Huth int i; \ 1839fcf5ef2aSThomas Huth \ 1840fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1841fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 1842fcf5ef2aSThomas Huth \ 1843fcf5ef2aSThomas Huth r->element[i] = a->element[i] << shift; \ 1844fcf5ef2aSThomas Huth } \ 1845fcf5ef2aSThomas Huth } 1846fcf5ef2aSThomas Huth VSL(b, u8, 0x7) 1847fcf5ef2aSThomas Huth VSL(h, u16, 0x0F) 1848fcf5ef2aSThomas Huth VSL(w, u32, 0x1F) 1849fcf5ef2aSThomas Huth VSL(d, u64, 0x3F) 1850fcf5ef2aSThomas Huth #undef VSL 1851fcf5ef2aSThomas Huth 1852fcf5ef2aSThomas Huth void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1853fcf5ef2aSThomas Huth { 1854fcf5ef2aSThomas Huth int i; 1855fcf5ef2aSThomas Huth unsigned int shift, bytes, size; 1856fcf5ef2aSThomas Huth 1857fcf5ef2aSThomas Huth size = ARRAY_SIZE(r->u8); 1858fcf5ef2aSThomas Huth for (i = 0; i < size; i++) { 1859fcf5ef2aSThomas Huth shift = b->u8[i] & 0x7; /* extract shift value */ 1860fcf5ef2aSThomas Huth bytes = (a->u8[i] << 8) + /* extract adjacent bytes */ 1861fcf5ef2aSThomas Huth (((i + 1) < size) ? a->u8[i + 1] : 0); 1862fcf5ef2aSThomas Huth r->u8[i] = (bytes << shift) >> 8; /* shift and store result */ 1863fcf5ef2aSThomas Huth } 1864fcf5ef2aSThomas Huth } 1865fcf5ef2aSThomas Huth 1866fcf5ef2aSThomas Huth void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1867fcf5ef2aSThomas Huth { 1868fcf5ef2aSThomas Huth int i; 1869fcf5ef2aSThomas Huth unsigned int shift, bytes; 1870fcf5ef2aSThomas Huth 1871fcf5ef2aSThomas Huth /* Use reverse order, as destination and source register can be same. Its 1872fcf5ef2aSThomas Huth * being modified in place saving temporary, reverse order will guarantee 1873fcf5ef2aSThomas Huth * that computed result is not fed back. 1874fcf5ef2aSThomas Huth */ 1875fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 1876fcf5ef2aSThomas Huth shift = b->u8[i] & 0x7; /* extract shift value */ 1877fcf5ef2aSThomas Huth bytes = ((i ? a->u8[i - 1] : 0) << 8) + a->u8[i]; 1878fcf5ef2aSThomas Huth /* extract adjacent bytes */ 1879fcf5ef2aSThomas Huth r->u8[i] = (bytes >> shift) & 0xFF; /* shift and store result */ 1880fcf5ef2aSThomas Huth } 1881fcf5ef2aSThomas Huth } 1882fcf5ef2aSThomas Huth 1883fcf5ef2aSThomas Huth void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift) 1884fcf5ef2aSThomas Huth { 1885fcf5ef2aSThomas Huth int sh = shift & 0xf; 1886fcf5ef2aSThomas Huth int i; 1887fcf5ef2aSThomas Huth ppc_avr_t result; 1888fcf5ef2aSThomas Huth 1889fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1890fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1891fcf5ef2aSThomas Huth int index = sh + i; 1892fcf5ef2aSThomas Huth if (index > 0xf) { 1893fcf5ef2aSThomas Huth result.u8[i] = b->u8[index - 0x10]; 1894fcf5ef2aSThomas Huth } else { 1895fcf5ef2aSThomas Huth result.u8[i] = a->u8[index]; 1896fcf5ef2aSThomas Huth } 1897fcf5ef2aSThomas Huth } 1898fcf5ef2aSThomas Huth #else 1899fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1900fcf5ef2aSThomas Huth int index = (16 - sh) + i; 1901fcf5ef2aSThomas Huth if (index > 0xf) { 1902fcf5ef2aSThomas Huth result.u8[i] = a->u8[index - 0x10]; 1903fcf5ef2aSThomas Huth } else { 1904fcf5ef2aSThomas Huth result.u8[i] = b->u8[index]; 1905fcf5ef2aSThomas Huth } 1906fcf5ef2aSThomas Huth } 1907fcf5ef2aSThomas Huth #endif 1908fcf5ef2aSThomas Huth *r = result; 1909fcf5ef2aSThomas Huth } 1910fcf5ef2aSThomas Huth 1911fcf5ef2aSThomas Huth void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1912fcf5ef2aSThomas Huth { 1913fcf5ef2aSThomas Huth int sh = (b->u8[LO_IDX*0xf] >> 3) & 0xf; 1914fcf5ef2aSThomas Huth 1915fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1916fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1917fcf5ef2aSThomas Huth memset(&r->u8[16-sh], 0, sh); 1918fcf5ef2aSThomas Huth #else 1919fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1920fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1921fcf5ef2aSThomas Huth #endif 1922fcf5ef2aSThomas Huth } 1923fcf5ef2aSThomas Huth 1924fcf5ef2aSThomas Huth /* Experimental testing shows that hardware masks the immediate. */ 1925fcf5ef2aSThomas Huth #define _SPLAT_MASKED(element) (splat & (ARRAY_SIZE(r->element) - 1)) 1926fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1927fcf5ef2aSThomas Huth #define SPLAT_ELEMENT(element) _SPLAT_MASKED(element) 1928fcf5ef2aSThomas Huth #else 1929fcf5ef2aSThomas Huth #define SPLAT_ELEMENT(element) \ 1930fcf5ef2aSThomas Huth (ARRAY_SIZE(r->element) - 1 - _SPLAT_MASKED(element)) 1931fcf5ef2aSThomas Huth #endif 1932fcf5ef2aSThomas Huth #define VSPLT(suffix, element) \ 1933fcf5ef2aSThomas Huth void helper_vsplt##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t splat) \ 1934fcf5ef2aSThomas Huth { \ 1935fcf5ef2aSThomas Huth uint32_t s = b->element[SPLAT_ELEMENT(element)]; \ 1936fcf5ef2aSThomas Huth int i; \ 1937fcf5ef2aSThomas Huth \ 1938fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1939fcf5ef2aSThomas Huth r->element[i] = s; \ 1940fcf5ef2aSThomas Huth } \ 1941fcf5ef2aSThomas Huth } 1942fcf5ef2aSThomas Huth VSPLT(b, u8) 1943fcf5ef2aSThomas Huth VSPLT(h, u16) 1944fcf5ef2aSThomas Huth VSPLT(w, u32) 1945fcf5ef2aSThomas Huth #undef VSPLT 1946fcf5ef2aSThomas Huth #undef SPLAT_ELEMENT 1947fcf5ef2aSThomas Huth #undef _SPLAT_MASKED 1948fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1949fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1950fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1951fcf5ef2aSThomas Huth { \ 19524fff7218SLaurent Vivier memmove(&r->u8[index], &b->u8[8 - sizeof(r->element[0])], \ 1953fcf5ef2aSThomas Huth sizeof(r->element[0])); \ 1954fcf5ef2aSThomas Huth } 1955fcf5ef2aSThomas Huth #else 1956fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1957fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1958fcf5ef2aSThomas Huth { \ 1959fcf5ef2aSThomas Huth uint32_t d = (16 - index) - sizeof(r->element[0]); \ 1960fcf5ef2aSThomas Huth memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0])); \ 1961fcf5ef2aSThomas Huth } 1962fcf5ef2aSThomas Huth #endif 1963fcf5ef2aSThomas Huth VINSERT(b, u8) 1964fcf5ef2aSThomas Huth VINSERT(h, u16) 1965fcf5ef2aSThomas Huth VINSERT(w, u32) 1966fcf5ef2aSThomas Huth VINSERT(d, u64) 1967fcf5ef2aSThomas Huth #undef VINSERT 1968fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1969fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1970fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1971fcf5ef2aSThomas Huth { \ 1972fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1973fcf5ef2aSThomas Huth memmove(&r->u8[8 - es], &b->u8[index], es); \ 1974fcf5ef2aSThomas Huth memset(&r->u8[8], 0, 8); \ 1975fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8 - es); \ 1976fcf5ef2aSThomas Huth } 1977fcf5ef2aSThomas Huth #else 1978fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1979fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1980fcf5ef2aSThomas Huth { \ 1981fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1982fcf5ef2aSThomas Huth uint32_t s = (16 - index) - es; \ 1983fcf5ef2aSThomas Huth memmove(&r->u8[8], &b->u8[s], es); \ 1984fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8); \ 1985fcf5ef2aSThomas Huth memset(&r->u8[8 + es], 0, 8 - es); \ 1986fcf5ef2aSThomas Huth } 1987fcf5ef2aSThomas Huth #endif 1988fcf5ef2aSThomas Huth VEXTRACT(ub, u8) 1989fcf5ef2aSThomas Huth VEXTRACT(uh, u16) 1990fcf5ef2aSThomas Huth VEXTRACT(uw, u32) 1991fcf5ef2aSThomas Huth VEXTRACT(d, u64) 1992fcf5ef2aSThomas Huth #undef VEXTRACT 1993fcf5ef2aSThomas Huth 19948ad901e5SNikunj A Dadhania void helper_xxextractuw(CPUPPCState *env, target_ulong xtn, 19958ad901e5SNikunj A Dadhania target_ulong xbn, uint32_t index) 19968ad901e5SNikunj A Dadhania { 19978ad901e5SNikunj A Dadhania ppc_vsr_t xt, xb; 19988ad901e5SNikunj A Dadhania size_t es = sizeof(uint32_t); 19998ad901e5SNikunj A Dadhania uint32_t ext_index; 20008ad901e5SNikunj A Dadhania int i; 20018ad901e5SNikunj A Dadhania 20028ad901e5SNikunj A Dadhania getVSR(xbn, &xb, env); 20038ad901e5SNikunj A Dadhania memset(&xt, 0, sizeof(xt)); 20048ad901e5SNikunj A Dadhania 20058ad901e5SNikunj A Dadhania #if defined(HOST_WORDS_BIGENDIAN) 20068ad901e5SNikunj A Dadhania ext_index = index; 20078ad901e5SNikunj A Dadhania for (i = 0; i < es; i++, ext_index++) { 20088ad901e5SNikunj A Dadhania xt.u8[8 - es + i] = xb.u8[ext_index % 16]; 20098ad901e5SNikunj A Dadhania } 20108ad901e5SNikunj A Dadhania #else 20118ad901e5SNikunj A Dadhania ext_index = 15 - index; 20128ad901e5SNikunj A Dadhania for (i = es - 1; i >= 0; i--, ext_index--) { 20138ad901e5SNikunj A Dadhania xt.u8[8 + i] = xb.u8[ext_index % 16]; 20148ad901e5SNikunj A Dadhania } 20158ad901e5SNikunj A Dadhania #endif 20168ad901e5SNikunj A Dadhania 20178ad901e5SNikunj A Dadhania putVSR(xtn, &xt, env); 20188ad901e5SNikunj A Dadhania } 20198ad901e5SNikunj A Dadhania 20203398b742SNikunj A Dadhania void helper_xxinsertw(CPUPPCState *env, target_ulong xtn, 20213398b742SNikunj A Dadhania target_ulong xbn, uint32_t index) 20223398b742SNikunj A Dadhania { 20233398b742SNikunj A Dadhania ppc_vsr_t xt, xb; 20243398b742SNikunj A Dadhania size_t es = sizeof(uint32_t); 20253398b742SNikunj A Dadhania int ins_index, i = 0; 20263398b742SNikunj A Dadhania 20273398b742SNikunj A Dadhania getVSR(xbn, &xb, env); 20283398b742SNikunj A Dadhania getVSR(xtn, &xt, env); 20293398b742SNikunj A Dadhania 20303398b742SNikunj A Dadhania #if defined(HOST_WORDS_BIGENDIAN) 20313398b742SNikunj A Dadhania ins_index = index; 20323398b742SNikunj A Dadhania for (i = 0; i < es && ins_index < 16; i++, ins_index++) { 20333398b742SNikunj A Dadhania xt.u8[ins_index] = xb.u8[8 - es + i]; 20343398b742SNikunj A Dadhania } 20353398b742SNikunj A Dadhania #else 20363398b742SNikunj A Dadhania ins_index = 15 - index; 20373398b742SNikunj A Dadhania for (i = es - 1; i >= 0 && ins_index >= 0; i--, ins_index--) { 20383398b742SNikunj A Dadhania xt.u8[ins_index] = xb.u8[8 + i]; 20393398b742SNikunj A Dadhania } 20403398b742SNikunj A Dadhania #endif 20413398b742SNikunj A Dadhania 20423398b742SNikunj A Dadhania putVSR(xtn, &xt, env); 20433398b742SNikunj A Dadhania } 20443398b742SNikunj A Dadhania 2045fcf5ef2aSThomas Huth #define VEXT_SIGNED(name, element, mask, cast, recast) \ 2046fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 2047fcf5ef2aSThomas Huth { \ 2048fcf5ef2aSThomas Huth int i; \ 2049fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, element) { \ 2050fcf5ef2aSThomas Huth r->element[i] = (recast)((cast)(b->element[i] & mask)); \ 2051fcf5ef2aSThomas Huth } \ 2052fcf5ef2aSThomas Huth } 2053fcf5ef2aSThomas Huth VEXT_SIGNED(vextsb2w, s32, UINT8_MAX, int8_t, int32_t) 2054fcf5ef2aSThomas Huth VEXT_SIGNED(vextsb2d, s64, UINT8_MAX, int8_t, int64_t) 2055fcf5ef2aSThomas Huth VEXT_SIGNED(vextsh2w, s32, UINT16_MAX, int16_t, int32_t) 2056fcf5ef2aSThomas Huth VEXT_SIGNED(vextsh2d, s64, UINT16_MAX, int16_t, int64_t) 2057fcf5ef2aSThomas Huth VEXT_SIGNED(vextsw2d, s64, UINT32_MAX, int32_t, int64_t) 2058fcf5ef2aSThomas Huth #undef VEXT_SIGNED 2059fcf5ef2aSThomas Huth 2060fcf5ef2aSThomas Huth #define VNEG(name, element) \ 2061fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 2062fcf5ef2aSThomas Huth { \ 2063fcf5ef2aSThomas Huth int i; \ 2064fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, element) { \ 2065fcf5ef2aSThomas Huth r->element[i] = -b->element[i]; \ 2066fcf5ef2aSThomas Huth } \ 2067fcf5ef2aSThomas Huth } 2068fcf5ef2aSThomas Huth VNEG(vnegw, s32) 2069fcf5ef2aSThomas Huth VNEG(vnegd, s64) 2070fcf5ef2aSThomas Huth #undef VNEG 2071fcf5ef2aSThomas Huth 2072fcf5ef2aSThomas Huth #define VSPLTI(suffix, element, splat_type) \ 2073fcf5ef2aSThomas Huth void helper_vspltis##suffix(ppc_avr_t *r, uint32_t splat) \ 2074fcf5ef2aSThomas Huth { \ 2075fcf5ef2aSThomas Huth splat_type x = (int8_t)(splat << 3) >> 3; \ 2076fcf5ef2aSThomas Huth int i; \ 2077fcf5ef2aSThomas Huth \ 2078fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 2079fcf5ef2aSThomas Huth r->element[i] = x; \ 2080fcf5ef2aSThomas Huth } \ 2081fcf5ef2aSThomas Huth } 2082fcf5ef2aSThomas Huth VSPLTI(b, s8, int8_t) 2083fcf5ef2aSThomas Huth VSPLTI(h, s16, int16_t) 2084fcf5ef2aSThomas Huth VSPLTI(w, s32, int32_t) 2085fcf5ef2aSThomas Huth #undef VSPLTI 2086fcf5ef2aSThomas Huth 2087fcf5ef2aSThomas Huth #define VSR(suffix, element, mask) \ 2088fcf5ef2aSThomas Huth void helper_vsr##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 2089fcf5ef2aSThomas Huth { \ 2090fcf5ef2aSThomas Huth int i; \ 2091fcf5ef2aSThomas Huth \ 2092fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 2093fcf5ef2aSThomas Huth unsigned int shift = b->element[i] & mask; \ 2094fcf5ef2aSThomas Huth r->element[i] = a->element[i] >> shift; \ 2095fcf5ef2aSThomas Huth } \ 2096fcf5ef2aSThomas Huth } 2097fcf5ef2aSThomas Huth VSR(ab, s8, 0x7) 2098fcf5ef2aSThomas Huth VSR(ah, s16, 0xF) 2099fcf5ef2aSThomas Huth VSR(aw, s32, 0x1F) 2100fcf5ef2aSThomas Huth VSR(ad, s64, 0x3F) 2101fcf5ef2aSThomas Huth VSR(b, u8, 0x7) 2102fcf5ef2aSThomas Huth VSR(h, u16, 0xF) 2103fcf5ef2aSThomas Huth VSR(w, u32, 0x1F) 2104fcf5ef2aSThomas Huth VSR(d, u64, 0x3F) 2105fcf5ef2aSThomas Huth #undef VSR 2106fcf5ef2aSThomas Huth 2107fcf5ef2aSThomas Huth void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2108fcf5ef2aSThomas Huth { 2109fcf5ef2aSThomas Huth int sh = (b->u8[LO_IDX * 0xf] >> 3) & 0xf; 2110fcf5ef2aSThomas Huth 2111fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2112fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 2113fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 2114fcf5ef2aSThomas Huth #else 2115fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 2116fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 2117fcf5ef2aSThomas Huth #endif 2118fcf5ef2aSThomas Huth } 2119fcf5ef2aSThomas Huth 2120fcf5ef2aSThomas Huth void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2121fcf5ef2aSThomas Huth { 2122fcf5ef2aSThomas Huth int i; 2123fcf5ef2aSThomas Huth 2124fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2125fcf5ef2aSThomas Huth r->u32[i] = a->u32[i] >= b->u32[i]; 2126fcf5ef2aSThomas Huth } 2127fcf5ef2aSThomas Huth } 2128fcf5ef2aSThomas Huth 2129fcf5ef2aSThomas Huth void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2130fcf5ef2aSThomas Huth { 2131fcf5ef2aSThomas Huth int64_t t; 2132fcf5ef2aSThomas Huth int i, upper; 2133fcf5ef2aSThomas Huth ppc_avr_t result; 2134fcf5ef2aSThomas Huth int sat = 0; 2135fcf5ef2aSThomas Huth 2136fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2137fcf5ef2aSThomas Huth upper = ARRAY_SIZE(r->s32)-1; 2138fcf5ef2aSThomas Huth #else 2139fcf5ef2aSThomas Huth upper = 0; 2140fcf5ef2aSThomas Huth #endif 2141fcf5ef2aSThomas Huth t = (int64_t)b->s32[upper]; 2142fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2143fcf5ef2aSThomas Huth t += a->s32[i]; 2144fcf5ef2aSThomas Huth result.s32[i] = 0; 2145fcf5ef2aSThomas Huth } 2146fcf5ef2aSThomas Huth result.s32[upper] = cvtsdsw(t, &sat); 2147fcf5ef2aSThomas Huth *r = result; 2148fcf5ef2aSThomas Huth 2149fcf5ef2aSThomas Huth if (sat) { 2150fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 2151fcf5ef2aSThomas Huth } 2152fcf5ef2aSThomas Huth } 2153fcf5ef2aSThomas Huth 2154fcf5ef2aSThomas Huth void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2155fcf5ef2aSThomas Huth { 2156fcf5ef2aSThomas Huth int i, j, upper; 2157fcf5ef2aSThomas Huth ppc_avr_t result; 2158fcf5ef2aSThomas Huth int sat = 0; 2159fcf5ef2aSThomas Huth 2160fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2161fcf5ef2aSThomas Huth upper = 1; 2162fcf5ef2aSThomas Huth #else 2163fcf5ef2aSThomas Huth upper = 0; 2164fcf5ef2aSThomas Huth #endif 2165fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 2166fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[upper + i * 2]; 2167fcf5ef2aSThomas Huth 2168fcf5ef2aSThomas Huth result.u64[i] = 0; 2169fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u64); j++) { 2170fcf5ef2aSThomas Huth t += a->s32[2 * i + j]; 2171fcf5ef2aSThomas Huth } 2172fcf5ef2aSThomas Huth result.s32[upper + i * 2] = cvtsdsw(t, &sat); 2173fcf5ef2aSThomas Huth } 2174fcf5ef2aSThomas Huth 2175fcf5ef2aSThomas Huth *r = result; 2176fcf5ef2aSThomas Huth if (sat) { 2177fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 2178fcf5ef2aSThomas Huth } 2179fcf5ef2aSThomas Huth } 2180fcf5ef2aSThomas Huth 2181fcf5ef2aSThomas Huth void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2182fcf5ef2aSThomas Huth { 2183fcf5ef2aSThomas Huth int i, j; 2184fcf5ef2aSThomas Huth int sat = 0; 2185fcf5ef2aSThomas Huth 2186fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2187fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2188fcf5ef2aSThomas Huth 2189fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->s32); j++) { 2190fcf5ef2aSThomas Huth t += a->s8[4 * i + j]; 2191fcf5ef2aSThomas Huth } 2192fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2193fcf5ef2aSThomas Huth } 2194fcf5ef2aSThomas Huth 2195fcf5ef2aSThomas Huth if (sat) { 2196fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 2197fcf5ef2aSThomas Huth } 2198fcf5ef2aSThomas Huth } 2199fcf5ef2aSThomas Huth 2200fcf5ef2aSThomas Huth void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2201fcf5ef2aSThomas Huth { 2202fcf5ef2aSThomas Huth int sat = 0; 2203fcf5ef2aSThomas Huth int i; 2204fcf5ef2aSThomas Huth 2205fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 2206fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 2207fcf5ef2aSThomas Huth 2208fcf5ef2aSThomas Huth t += a->s16[2 * i] + a->s16[2 * i + 1]; 2209fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 2210fcf5ef2aSThomas Huth } 2211fcf5ef2aSThomas Huth 2212fcf5ef2aSThomas Huth if (sat) { 2213fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 2214fcf5ef2aSThomas Huth } 2215fcf5ef2aSThomas Huth } 2216fcf5ef2aSThomas Huth 2217fcf5ef2aSThomas Huth void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2218fcf5ef2aSThomas Huth { 2219fcf5ef2aSThomas Huth int i, j; 2220fcf5ef2aSThomas Huth int sat = 0; 2221fcf5ef2aSThomas Huth 2222fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2223fcf5ef2aSThomas Huth uint64_t t = (uint64_t)b->u32[i]; 2224fcf5ef2aSThomas Huth 2225fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u32); j++) { 2226fcf5ef2aSThomas Huth t += a->u8[4 * i + j]; 2227fcf5ef2aSThomas Huth } 2228fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 2229fcf5ef2aSThomas Huth } 2230fcf5ef2aSThomas Huth 2231fcf5ef2aSThomas Huth if (sat) { 2232fcf5ef2aSThomas Huth env->vscr |= (1 << VSCR_SAT); 2233fcf5ef2aSThomas Huth } 2234fcf5ef2aSThomas Huth } 2235fcf5ef2aSThomas Huth 2236fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2237fcf5ef2aSThomas Huth #define UPKHI 1 2238fcf5ef2aSThomas Huth #define UPKLO 0 2239fcf5ef2aSThomas Huth #else 2240fcf5ef2aSThomas Huth #define UPKHI 0 2241fcf5ef2aSThomas Huth #define UPKLO 1 2242fcf5ef2aSThomas Huth #endif 2243fcf5ef2aSThomas Huth #define VUPKPX(suffix, hi) \ 2244fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2245fcf5ef2aSThomas Huth { \ 2246fcf5ef2aSThomas Huth int i; \ 2247fcf5ef2aSThomas Huth ppc_avr_t result; \ 2248fcf5ef2aSThomas Huth \ 2249fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \ 2250fcf5ef2aSThomas Huth uint16_t e = b->u16[hi ? i : i+4]; \ 2251fcf5ef2aSThomas Huth uint8_t a = (e >> 15) ? 0xff : 0; \ 2252fcf5ef2aSThomas Huth uint8_t r = (e >> 10) & 0x1f; \ 2253fcf5ef2aSThomas Huth uint8_t g = (e >> 5) & 0x1f; \ 2254fcf5ef2aSThomas Huth uint8_t b = e & 0x1f; \ 2255fcf5ef2aSThomas Huth \ 2256fcf5ef2aSThomas Huth result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \ 2257fcf5ef2aSThomas Huth } \ 2258fcf5ef2aSThomas Huth *r = result; \ 2259fcf5ef2aSThomas Huth } 2260fcf5ef2aSThomas Huth VUPKPX(lpx, UPKLO) 2261fcf5ef2aSThomas Huth VUPKPX(hpx, UPKHI) 2262fcf5ef2aSThomas Huth #undef VUPKPX 2263fcf5ef2aSThomas Huth 2264fcf5ef2aSThomas Huth #define VUPK(suffix, unpacked, packee, hi) \ 2265fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 2266fcf5ef2aSThomas Huth { \ 2267fcf5ef2aSThomas Huth int i; \ 2268fcf5ef2aSThomas Huth ppc_avr_t result; \ 2269fcf5ef2aSThomas Huth \ 2270fcf5ef2aSThomas Huth if (hi) { \ 2271fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \ 2272fcf5ef2aSThomas Huth result.unpacked[i] = b->packee[i]; \ 2273fcf5ef2aSThomas Huth } \ 2274fcf5ef2aSThomas Huth } else { \ 2275fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \ 2276fcf5ef2aSThomas Huth i++) { \ 2277fcf5ef2aSThomas Huth result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \ 2278fcf5ef2aSThomas Huth } \ 2279fcf5ef2aSThomas Huth } \ 2280fcf5ef2aSThomas Huth *r = result; \ 2281fcf5ef2aSThomas Huth } 2282fcf5ef2aSThomas Huth VUPK(hsb, s16, s8, UPKHI) 2283fcf5ef2aSThomas Huth VUPK(hsh, s32, s16, UPKHI) 2284fcf5ef2aSThomas Huth VUPK(hsw, s64, s32, UPKHI) 2285fcf5ef2aSThomas Huth VUPK(lsb, s16, s8, UPKLO) 2286fcf5ef2aSThomas Huth VUPK(lsh, s32, s16, UPKLO) 2287fcf5ef2aSThomas Huth VUPK(lsw, s64, s32, UPKLO) 2288fcf5ef2aSThomas Huth #undef VUPK 2289fcf5ef2aSThomas Huth #undef UPKHI 2290fcf5ef2aSThomas Huth #undef UPKLO 2291fcf5ef2aSThomas Huth 2292fcf5ef2aSThomas Huth #define VGENERIC_DO(name, element) \ 2293fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \ 2294fcf5ef2aSThomas Huth { \ 2295fcf5ef2aSThomas Huth int i; \ 2296fcf5ef2aSThomas Huth \ 2297fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, element) { \ 2298fcf5ef2aSThomas Huth r->element[i] = name(b->element[i]); \ 2299fcf5ef2aSThomas Huth } \ 2300fcf5ef2aSThomas Huth } 2301fcf5ef2aSThomas Huth 2302fcf5ef2aSThomas Huth #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8) 2303fcf5ef2aSThomas Huth #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16) 2304fcf5ef2aSThomas Huth #define clzw(v) clz32((v)) 2305fcf5ef2aSThomas Huth #define clzd(v) clz64((v)) 2306fcf5ef2aSThomas Huth 2307fcf5ef2aSThomas Huth VGENERIC_DO(clzb, u8) 2308fcf5ef2aSThomas Huth VGENERIC_DO(clzh, u16) 2309fcf5ef2aSThomas Huth VGENERIC_DO(clzw, u32) 2310fcf5ef2aSThomas Huth VGENERIC_DO(clzd, u64) 2311fcf5ef2aSThomas Huth 2312fcf5ef2aSThomas Huth #undef clzb 2313fcf5ef2aSThomas Huth #undef clzh 2314fcf5ef2aSThomas Huth #undef clzw 2315fcf5ef2aSThomas Huth #undef clzd 2316fcf5ef2aSThomas Huth 2317fcf5ef2aSThomas Huth #define ctzb(v) ((v) ? ctz32(v) : 8) 2318fcf5ef2aSThomas Huth #define ctzh(v) ((v) ? ctz32(v) : 16) 2319fcf5ef2aSThomas Huth #define ctzw(v) ctz32((v)) 2320fcf5ef2aSThomas Huth #define ctzd(v) ctz64((v)) 2321fcf5ef2aSThomas Huth 2322fcf5ef2aSThomas Huth VGENERIC_DO(ctzb, u8) 2323fcf5ef2aSThomas Huth VGENERIC_DO(ctzh, u16) 2324fcf5ef2aSThomas Huth VGENERIC_DO(ctzw, u32) 2325fcf5ef2aSThomas Huth VGENERIC_DO(ctzd, u64) 2326fcf5ef2aSThomas Huth 2327fcf5ef2aSThomas Huth #undef ctzb 2328fcf5ef2aSThomas Huth #undef ctzh 2329fcf5ef2aSThomas Huth #undef ctzw 2330fcf5ef2aSThomas Huth #undef ctzd 2331fcf5ef2aSThomas Huth 2332fcf5ef2aSThomas Huth #define popcntb(v) ctpop8(v) 2333fcf5ef2aSThomas Huth #define popcnth(v) ctpop16(v) 2334fcf5ef2aSThomas Huth #define popcntw(v) ctpop32(v) 2335fcf5ef2aSThomas Huth #define popcntd(v) ctpop64(v) 2336fcf5ef2aSThomas Huth 2337fcf5ef2aSThomas Huth VGENERIC_DO(popcntb, u8) 2338fcf5ef2aSThomas Huth VGENERIC_DO(popcnth, u16) 2339fcf5ef2aSThomas Huth VGENERIC_DO(popcntw, u32) 2340fcf5ef2aSThomas Huth VGENERIC_DO(popcntd, u64) 2341fcf5ef2aSThomas Huth 2342fcf5ef2aSThomas Huth #undef popcntb 2343fcf5ef2aSThomas Huth #undef popcnth 2344fcf5ef2aSThomas Huth #undef popcntw 2345fcf5ef2aSThomas Huth #undef popcntd 2346fcf5ef2aSThomas Huth 2347fcf5ef2aSThomas Huth #undef VGENERIC_DO 2348fcf5ef2aSThomas Huth 2349fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2350fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 0, 1 } } 2351fcf5ef2aSThomas Huth #else 2352fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 1, 0 } } 2353fcf5ef2aSThomas Huth #endif 2354fcf5ef2aSThomas Huth 2355fcf5ef2aSThomas Huth #ifndef CONFIG_INT128 2356fcf5ef2aSThomas Huth 2357fcf5ef2aSThomas Huth static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a) 2358fcf5ef2aSThomas Huth { 2359fcf5ef2aSThomas Huth t->u64[0] = ~a.u64[0]; 2360fcf5ef2aSThomas Huth t->u64[1] = ~a.u64[1]; 2361fcf5ef2aSThomas Huth } 2362fcf5ef2aSThomas Huth 2363fcf5ef2aSThomas Huth static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b) 2364fcf5ef2aSThomas Huth { 2365fcf5ef2aSThomas Huth if (a.u64[HI_IDX] < b.u64[HI_IDX]) { 2366fcf5ef2aSThomas Huth return -1; 2367fcf5ef2aSThomas Huth } else if (a.u64[HI_IDX] > b.u64[HI_IDX]) { 2368fcf5ef2aSThomas Huth return 1; 2369fcf5ef2aSThomas Huth } else if (a.u64[LO_IDX] < b.u64[LO_IDX]) { 2370fcf5ef2aSThomas Huth return -1; 2371fcf5ef2aSThomas Huth } else if (a.u64[LO_IDX] > b.u64[LO_IDX]) { 2372fcf5ef2aSThomas Huth return 1; 2373fcf5ef2aSThomas Huth } else { 2374fcf5ef2aSThomas Huth return 0; 2375fcf5ef2aSThomas Huth } 2376fcf5ef2aSThomas Huth } 2377fcf5ef2aSThomas Huth 2378fcf5ef2aSThomas Huth static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2379fcf5ef2aSThomas Huth { 2380fcf5ef2aSThomas Huth t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX]; 2381fcf5ef2aSThomas Huth t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] + 2382fcf5ef2aSThomas Huth (~a.u64[LO_IDX] < b.u64[LO_IDX]); 2383fcf5ef2aSThomas Huth } 2384fcf5ef2aSThomas Huth 2385fcf5ef2aSThomas Huth static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2386fcf5ef2aSThomas Huth { 2387fcf5ef2aSThomas Huth ppc_avr_t not_a; 2388fcf5ef2aSThomas Huth t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX]; 2389fcf5ef2aSThomas Huth t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] + 2390fcf5ef2aSThomas Huth (~a.u64[LO_IDX] < b.u64[LO_IDX]); 2391fcf5ef2aSThomas Huth avr_qw_not(¬_a, a); 2392fcf5ef2aSThomas Huth return avr_qw_cmpu(not_a, b) < 0; 2393fcf5ef2aSThomas Huth } 2394fcf5ef2aSThomas Huth 2395fcf5ef2aSThomas Huth #endif 2396fcf5ef2aSThomas Huth 2397fcf5ef2aSThomas Huth void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2398fcf5ef2aSThomas Huth { 2399fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2400fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128; 2401fcf5ef2aSThomas Huth #else 2402fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2403fcf5ef2aSThomas Huth #endif 2404fcf5ef2aSThomas Huth } 2405fcf5ef2aSThomas Huth 2406fcf5ef2aSThomas Huth void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2407fcf5ef2aSThomas Huth { 2408fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2409fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128 + (c->u128 & 1); 2410fcf5ef2aSThomas Huth #else 2411fcf5ef2aSThomas Huth 2412fcf5ef2aSThomas Huth if (c->u64[LO_IDX] & 1) { 2413fcf5ef2aSThomas Huth ppc_avr_t tmp; 2414fcf5ef2aSThomas Huth 2415fcf5ef2aSThomas Huth tmp.u64[HI_IDX] = 0; 2416fcf5ef2aSThomas Huth tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1; 2417fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2418fcf5ef2aSThomas Huth avr_qw_add(r, tmp, *b); 2419fcf5ef2aSThomas Huth } else { 2420fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2421fcf5ef2aSThomas Huth } 2422fcf5ef2aSThomas Huth #endif 2423fcf5ef2aSThomas Huth } 2424fcf5ef2aSThomas Huth 2425fcf5ef2aSThomas Huth void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2426fcf5ef2aSThomas Huth { 2427fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2428fcf5ef2aSThomas Huth r->u128 = (~a->u128 < b->u128); 2429fcf5ef2aSThomas Huth #else 2430fcf5ef2aSThomas Huth ppc_avr_t not_a; 2431fcf5ef2aSThomas Huth 2432fcf5ef2aSThomas Huth avr_qw_not(¬_a, *a); 2433fcf5ef2aSThomas Huth 2434fcf5ef2aSThomas Huth r->u64[HI_IDX] = 0; 2435fcf5ef2aSThomas Huth r->u64[LO_IDX] = (avr_qw_cmpu(not_a, *b) < 0); 2436fcf5ef2aSThomas Huth #endif 2437fcf5ef2aSThomas Huth } 2438fcf5ef2aSThomas Huth 2439fcf5ef2aSThomas Huth void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2440fcf5ef2aSThomas Huth { 2441fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2442fcf5ef2aSThomas Huth int carry_out = (~a->u128 < b->u128); 2443fcf5ef2aSThomas Huth if (!carry_out && (c->u128 & 1)) { 2444fcf5ef2aSThomas Huth carry_out = ((a->u128 + b->u128 + 1) == 0) && 2445fcf5ef2aSThomas Huth ((a->u128 != 0) || (b->u128 != 0)); 2446fcf5ef2aSThomas Huth } 2447fcf5ef2aSThomas Huth r->u128 = carry_out; 2448fcf5ef2aSThomas Huth #else 2449fcf5ef2aSThomas Huth 2450fcf5ef2aSThomas Huth int carry_in = c->u64[LO_IDX] & 1; 2451fcf5ef2aSThomas Huth int carry_out = 0; 2452fcf5ef2aSThomas Huth ppc_avr_t tmp; 2453fcf5ef2aSThomas Huth 2454fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, *a, *b); 2455fcf5ef2aSThomas Huth 2456fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2457fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2458fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, tmp, one); 2459fcf5ef2aSThomas Huth } 2460fcf5ef2aSThomas Huth r->u64[HI_IDX] = 0; 2461fcf5ef2aSThomas Huth r->u64[LO_IDX] = carry_out; 2462fcf5ef2aSThomas Huth #endif 2463fcf5ef2aSThomas Huth } 2464fcf5ef2aSThomas Huth 2465fcf5ef2aSThomas Huth void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2466fcf5ef2aSThomas Huth { 2467fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2468fcf5ef2aSThomas Huth r->u128 = a->u128 - b->u128; 2469fcf5ef2aSThomas Huth #else 2470fcf5ef2aSThomas Huth ppc_avr_t tmp; 2471fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2472fcf5ef2aSThomas Huth 2473fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2474fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2475fcf5ef2aSThomas Huth avr_qw_add(r, tmp, one); 2476fcf5ef2aSThomas Huth #endif 2477fcf5ef2aSThomas Huth } 2478fcf5ef2aSThomas Huth 2479fcf5ef2aSThomas Huth void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2480fcf5ef2aSThomas Huth { 2481fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2482fcf5ef2aSThomas Huth r->u128 = a->u128 + ~b->u128 + (c->u128 & 1); 2483fcf5ef2aSThomas Huth #else 2484fcf5ef2aSThomas Huth ppc_avr_t tmp, sum; 2485fcf5ef2aSThomas Huth 2486fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2487fcf5ef2aSThomas Huth avr_qw_add(&sum, *a, tmp); 2488fcf5ef2aSThomas Huth 2489fcf5ef2aSThomas Huth tmp.u64[HI_IDX] = 0; 2490fcf5ef2aSThomas Huth tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1; 2491fcf5ef2aSThomas Huth avr_qw_add(r, sum, tmp); 2492fcf5ef2aSThomas Huth #endif 2493fcf5ef2aSThomas Huth } 2494fcf5ef2aSThomas Huth 2495fcf5ef2aSThomas Huth void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2496fcf5ef2aSThomas Huth { 2497fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2498fcf5ef2aSThomas Huth r->u128 = (~a->u128 < ~b->u128) || 2499fcf5ef2aSThomas Huth (a->u128 + ~b->u128 == (__uint128_t)-1); 2500fcf5ef2aSThomas Huth #else 2501fcf5ef2aSThomas Huth int carry = (avr_qw_cmpu(*a, *b) > 0); 2502fcf5ef2aSThomas Huth if (!carry) { 2503fcf5ef2aSThomas Huth ppc_avr_t tmp; 2504fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2505fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2506fcf5ef2aSThomas Huth carry = ((tmp.s64[HI_IDX] == -1ull) && (tmp.s64[LO_IDX] == -1ull)); 2507fcf5ef2aSThomas Huth } 2508fcf5ef2aSThomas Huth r->u64[HI_IDX] = 0; 2509fcf5ef2aSThomas Huth r->u64[LO_IDX] = carry; 2510fcf5ef2aSThomas Huth #endif 2511fcf5ef2aSThomas Huth } 2512fcf5ef2aSThomas Huth 2513fcf5ef2aSThomas Huth void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2514fcf5ef2aSThomas Huth { 2515fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2516fcf5ef2aSThomas Huth r->u128 = 2517fcf5ef2aSThomas Huth (~a->u128 < ~b->u128) || 2518fcf5ef2aSThomas Huth ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1)); 2519fcf5ef2aSThomas Huth #else 2520fcf5ef2aSThomas Huth int carry_in = c->u64[LO_IDX] & 1; 2521fcf5ef2aSThomas Huth int carry_out = (avr_qw_cmpu(*a, *b) > 0); 2522fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2523fcf5ef2aSThomas Huth ppc_avr_t tmp; 2524fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2525fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2526fcf5ef2aSThomas Huth carry_out = ((tmp.u64[HI_IDX] == -1ull) && (tmp.u64[LO_IDX] == -1ull)); 2527fcf5ef2aSThomas Huth } 2528fcf5ef2aSThomas Huth 2529fcf5ef2aSThomas Huth r->u64[HI_IDX] = 0; 2530fcf5ef2aSThomas Huth r->u64[LO_IDX] = carry_out; 2531fcf5ef2aSThomas Huth #endif 2532fcf5ef2aSThomas Huth } 2533fcf5ef2aSThomas Huth 2534fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_1 0xC 2535fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_2 0xF 2536fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_1 0xA 2537fcf5ef2aSThomas Huth #define BCD_NEG_PREF 0xD 2538fcf5ef2aSThomas Huth #define BCD_NEG_ALT 0xB 2539fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_2 0xE 2540fcf5ef2aSThomas Huth #define NATIONAL_PLUS 0x2B 2541fcf5ef2aSThomas Huth #define NATIONAL_NEG 0x2D 2542fcf5ef2aSThomas Huth 2543fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2544365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) (15 - ((n) / 2)) 2545fcf5ef2aSThomas Huth #else 2546365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) ((n) / 2) 2547fcf5ef2aSThomas Huth #endif 2548fcf5ef2aSThomas Huth 2549fcf5ef2aSThomas Huth static int bcd_get_sgn(ppc_avr_t *bcd) 2550fcf5ef2aSThomas Huth { 2551fcf5ef2aSThomas Huth switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) { 2552fcf5ef2aSThomas Huth case BCD_PLUS_PREF_1: 2553fcf5ef2aSThomas Huth case BCD_PLUS_PREF_2: 2554fcf5ef2aSThomas Huth case BCD_PLUS_ALT_1: 2555fcf5ef2aSThomas Huth case BCD_PLUS_ALT_2: 2556fcf5ef2aSThomas Huth { 2557fcf5ef2aSThomas Huth return 1; 2558fcf5ef2aSThomas Huth } 2559fcf5ef2aSThomas Huth 2560fcf5ef2aSThomas Huth case BCD_NEG_PREF: 2561fcf5ef2aSThomas Huth case BCD_NEG_ALT: 2562fcf5ef2aSThomas Huth { 2563fcf5ef2aSThomas Huth return -1; 2564fcf5ef2aSThomas Huth } 2565fcf5ef2aSThomas Huth 2566fcf5ef2aSThomas Huth default: 2567fcf5ef2aSThomas Huth { 2568fcf5ef2aSThomas Huth return 0; 2569fcf5ef2aSThomas Huth } 2570fcf5ef2aSThomas Huth } 2571fcf5ef2aSThomas Huth } 2572fcf5ef2aSThomas Huth 2573fcf5ef2aSThomas Huth static int bcd_preferred_sgn(int sgn, int ps) 2574fcf5ef2aSThomas Huth { 2575fcf5ef2aSThomas Huth if (sgn >= 0) { 2576fcf5ef2aSThomas Huth return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2; 2577fcf5ef2aSThomas Huth } else { 2578fcf5ef2aSThomas Huth return BCD_NEG_PREF; 2579fcf5ef2aSThomas Huth } 2580fcf5ef2aSThomas Huth } 2581fcf5ef2aSThomas Huth 2582fcf5ef2aSThomas Huth static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid) 2583fcf5ef2aSThomas Huth { 2584fcf5ef2aSThomas Huth uint8_t result; 2585fcf5ef2aSThomas Huth if (n & 1) { 2586fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] >> 4; 2587fcf5ef2aSThomas Huth } else { 2588fcf5ef2aSThomas Huth result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF; 2589fcf5ef2aSThomas Huth } 2590fcf5ef2aSThomas Huth 2591fcf5ef2aSThomas Huth if (unlikely(result > 9)) { 2592fcf5ef2aSThomas Huth *invalid = true; 2593fcf5ef2aSThomas Huth } 2594fcf5ef2aSThomas Huth return result; 2595fcf5ef2aSThomas Huth } 2596fcf5ef2aSThomas Huth 2597fcf5ef2aSThomas Huth static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n) 2598fcf5ef2aSThomas Huth { 2599fcf5ef2aSThomas Huth if (n & 1) { 2600fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F; 2601fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= (digit<<4); 2602fcf5ef2aSThomas Huth } else { 2603fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0; 2604fcf5ef2aSThomas Huth bcd->u8[BCD_DIG_BYTE(n)] |= digit; 2605fcf5ef2aSThomas Huth } 2606fcf5ef2aSThomas Huth } 2607fcf5ef2aSThomas Huth 2608071663dfSJose Ricardo Ziviani static bool bcd_is_valid(ppc_avr_t *bcd) 2609071663dfSJose Ricardo Ziviani { 2610071663dfSJose Ricardo Ziviani int i; 2611071663dfSJose Ricardo Ziviani int invalid = 0; 2612071663dfSJose Ricardo Ziviani 2613071663dfSJose Ricardo Ziviani if (bcd_get_sgn(bcd) == 0) { 2614071663dfSJose Ricardo Ziviani return false; 2615071663dfSJose Ricardo Ziviani } 2616071663dfSJose Ricardo Ziviani 2617071663dfSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2618071663dfSJose Ricardo Ziviani bcd_get_digit(bcd, i, &invalid); 2619071663dfSJose Ricardo Ziviani if (unlikely(invalid)) { 2620071663dfSJose Ricardo Ziviani return false; 2621071663dfSJose Ricardo Ziviani } 2622071663dfSJose Ricardo Ziviani } 2623071663dfSJose Ricardo Ziviani return true; 2624071663dfSJose Ricardo Ziviani } 2625071663dfSJose Ricardo Ziviani 2626fcf5ef2aSThomas Huth static int bcd_cmp_zero(ppc_avr_t *bcd) 2627fcf5ef2aSThomas Huth { 2628fcf5ef2aSThomas Huth if (bcd->u64[HI_IDX] == 0 && (bcd->u64[LO_IDX] >> 4) == 0) { 2629efa73196SNikunj A Dadhania return CRF_EQ; 2630fcf5ef2aSThomas Huth } else { 2631efa73196SNikunj A Dadhania return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT; 2632fcf5ef2aSThomas Huth } 2633fcf5ef2aSThomas Huth } 2634fcf5ef2aSThomas Huth 2635fcf5ef2aSThomas Huth static uint16_t get_national_digit(ppc_avr_t *reg, int n) 2636fcf5ef2aSThomas Huth { 2637fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2638fcf5ef2aSThomas Huth return reg->u16[7 - n]; 2639fcf5ef2aSThomas Huth #else 2640fcf5ef2aSThomas Huth return reg->u16[n]; 2641fcf5ef2aSThomas Huth #endif 2642fcf5ef2aSThomas Huth } 2643fcf5ef2aSThomas Huth 2644fcf5ef2aSThomas Huth static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n) 2645fcf5ef2aSThomas Huth { 2646fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 2647fcf5ef2aSThomas Huth reg->u16[7 - n] = val; 2648fcf5ef2aSThomas Huth #else 2649fcf5ef2aSThomas Huth reg->u16[n] = val; 2650fcf5ef2aSThomas Huth #endif 2651fcf5ef2aSThomas Huth } 2652fcf5ef2aSThomas Huth 2653fcf5ef2aSThomas Huth static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b) 2654fcf5ef2aSThomas Huth { 2655fcf5ef2aSThomas Huth int i; 2656fcf5ef2aSThomas Huth int invalid = 0; 2657fcf5ef2aSThomas Huth for (i = 31; i > 0; i--) { 2658fcf5ef2aSThomas Huth uint8_t dig_a = bcd_get_digit(a, i, &invalid); 2659fcf5ef2aSThomas Huth uint8_t dig_b = bcd_get_digit(b, i, &invalid); 2660fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2661fcf5ef2aSThomas Huth return 0; /* doesn't matter */ 2662fcf5ef2aSThomas Huth } else if (dig_a > dig_b) { 2663fcf5ef2aSThomas Huth return 1; 2664fcf5ef2aSThomas Huth } else if (dig_a < dig_b) { 2665fcf5ef2aSThomas Huth return -1; 2666fcf5ef2aSThomas Huth } 2667fcf5ef2aSThomas Huth } 2668fcf5ef2aSThomas Huth 2669fcf5ef2aSThomas Huth return 0; 2670fcf5ef2aSThomas Huth } 2671fcf5ef2aSThomas Huth 2672d03b174aSYasmin Beatriz static void bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2673fcf5ef2aSThomas Huth int *overflow) 2674fcf5ef2aSThomas Huth { 2675fcf5ef2aSThomas Huth int carry = 0; 2676fcf5ef2aSThomas Huth int i; 2677fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2678fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) + 2679fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2680fcf5ef2aSThomas Huth if (digit > 9) { 2681fcf5ef2aSThomas Huth carry = 1; 2682fcf5ef2aSThomas Huth digit -= 10; 2683fcf5ef2aSThomas Huth } else { 2684fcf5ef2aSThomas Huth carry = 0; 2685fcf5ef2aSThomas Huth } 2686fcf5ef2aSThomas Huth 2687fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2688fcf5ef2aSThomas Huth } 2689fcf5ef2aSThomas Huth 2690fcf5ef2aSThomas Huth *overflow = carry; 2691fcf5ef2aSThomas Huth } 2692fcf5ef2aSThomas Huth 2693d03b174aSYasmin Beatriz static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2694fcf5ef2aSThomas Huth int *overflow) 2695fcf5ef2aSThomas Huth { 2696fcf5ef2aSThomas Huth int carry = 0; 2697fcf5ef2aSThomas Huth int i; 2698d03b174aSYasmin Beatriz 2699fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2700fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) - 2701fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2702fcf5ef2aSThomas Huth if (digit & 0x80) { 2703fcf5ef2aSThomas Huth carry = -1; 2704fcf5ef2aSThomas Huth digit += 10; 2705fcf5ef2aSThomas Huth } else { 2706fcf5ef2aSThomas Huth carry = 0; 2707fcf5ef2aSThomas Huth } 2708fcf5ef2aSThomas Huth 2709fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2710fcf5ef2aSThomas Huth } 2711fcf5ef2aSThomas Huth 2712fcf5ef2aSThomas Huth *overflow = carry; 2713fcf5ef2aSThomas Huth } 2714fcf5ef2aSThomas Huth 2715fcf5ef2aSThomas Huth uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2716fcf5ef2aSThomas Huth { 2717fcf5ef2aSThomas Huth 2718fcf5ef2aSThomas Huth int sgna = bcd_get_sgn(a); 2719fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2720fcf5ef2aSThomas Huth int invalid = (sgna == 0) || (sgnb == 0); 2721fcf5ef2aSThomas Huth int overflow = 0; 2722fcf5ef2aSThomas Huth uint32_t cr = 0; 2723fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 2724fcf5ef2aSThomas Huth 2725fcf5ef2aSThomas Huth if (!invalid) { 2726fcf5ef2aSThomas Huth if (sgna == sgnb) { 2727fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2728d03b174aSYasmin Beatriz bcd_add_mag(&result, a, b, &invalid, &overflow); 2729d03b174aSYasmin Beatriz cr = bcd_cmp_zero(&result); 2730fcf5ef2aSThomas Huth } else { 2731d03b174aSYasmin Beatriz int magnitude = bcd_cmp_mag(a, b); 2732d03b174aSYasmin Beatriz if (magnitude > 0) { 2733d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps); 2734d03b174aSYasmin Beatriz bcd_sub_mag(&result, a, b, &invalid, &overflow); 2735d03b174aSYasmin Beatriz cr = (sgna > 0) ? CRF_GT : CRF_LT; 2736d03b174aSYasmin Beatriz } else if (magnitude < 0) { 2737fcf5ef2aSThomas Huth result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps); 2738d03b174aSYasmin Beatriz bcd_sub_mag(&result, b, a, &invalid, &overflow); 2739efa73196SNikunj A Dadhania cr = (sgnb > 0) ? CRF_GT : CRF_LT; 2740d03b174aSYasmin Beatriz } else { 2741d03b174aSYasmin Beatriz result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(0, ps); 2742d03b174aSYasmin Beatriz cr = CRF_EQ; 2743d03b174aSYasmin Beatriz } 2744fcf5ef2aSThomas Huth } 2745fcf5ef2aSThomas Huth } 2746fcf5ef2aSThomas Huth 2747fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2748fcf5ef2aSThomas Huth result.u64[HI_IDX] = result.u64[LO_IDX] = -1; 2749efa73196SNikunj A Dadhania cr = CRF_SO; 2750fcf5ef2aSThomas Huth } else if (overflow) { 2751efa73196SNikunj A Dadhania cr |= CRF_SO; 2752fcf5ef2aSThomas Huth } 2753fcf5ef2aSThomas Huth 2754fcf5ef2aSThomas Huth *r = result; 2755fcf5ef2aSThomas Huth 2756fcf5ef2aSThomas Huth return cr; 2757fcf5ef2aSThomas Huth } 2758fcf5ef2aSThomas Huth 2759fcf5ef2aSThomas Huth uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2760fcf5ef2aSThomas Huth { 2761fcf5ef2aSThomas Huth ppc_avr_t bcopy = *b; 2762fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2763fcf5ef2aSThomas Huth if (sgnb < 0) { 2764fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0); 2765fcf5ef2aSThomas Huth } else if (sgnb > 0) { 2766fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_NEG_PREF, 0); 2767fcf5ef2aSThomas Huth } 2768fcf5ef2aSThomas Huth /* else invalid ... defer to bcdadd code for proper handling */ 2769fcf5ef2aSThomas Huth 2770fcf5ef2aSThomas Huth return helper_bcdadd(r, a, &bcopy, ps); 2771fcf5ef2aSThomas Huth } 2772fcf5ef2aSThomas Huth 2773fcf5ef2aSThomas Huth uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2774fcf5ef2aSThomas Huth { 2775fcf5ef2aSThomas Huth int i; 2776fcf5ef2aSThomas Huth int cr = 0; 2777fcf5ef2aSThomas Huth uint16_t national = 0; 2778fcf5ef2aSThomas Huth uint16_t sgnb = get_national_digit(b, 0); 2779fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2780fcf5ef2aSThomas Huth int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG); 2781fcf5ef2aSThomas Huth 2782fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2783fcf5ef2aSThomas Huth national = get_national_digit(b, i); 2784fcf5ef2aSThomas Huth if (unlikely(national < 0x30 || national > 0x39)) { 2785fcf5ef2aSThomas Huth invalid = 1; 2786fcf5ef2aSThomas Huth break; 2787fcf5ef2aSThomas Huth } 2788fcf5ef2aSThomas Huth 2789fcf5ef2aSThomas Huth bcd_put_digit(&ret, national & 0xf, i); 2790fcf5ef2aSThomas Huth } 2791fcf5ef2aSThomas Huth 2792fcf5ef2aSThomas Huth if (sgnb == NATIONAL_PLUS) { 2793fcf5ef2aSThomas Huth bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0); 2794fcf5ef2aSThomas Huth } else { 2795fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2796fcf5ef2aSThomas Huth } 2797fcf5ef2aSThomas Huth 2798fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2799fcf5ef2aSThomas Huth 2800fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2801efa73196SNikunj A Dadhania cr = CRF_SO; 2802fcf5ef2aSThomas Huth } 2803fcf5ef2aSThomas Huth 2804fcf5ef2aSThomas Huth *r = ret; 2805fcf5ef2aSThomas Huth 2806fcf5ef2aSThomas Huth return cr; 2807fcf5ef2aSThomas Huth } 2808fcf5ef2aSThomas Huth 2809fcf5ef2aSThomas Huth uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2810fcf5ef2aSThomas Huth { 2811fcf5ef2aSThomas Huth int i; 2812fcf5ef2aSThomas Huth int cr = 0; 2813fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2814fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2815fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2816fcf5ef2aSThomas Huth 2817fcf5ef2aSThomas Huth int ox_flag = (b->u64[HI_IDX] != 0) || ((b->u64[LO_IDX] >> 32) != 0); 2818fcf5ef2aSThomas Huth 2819fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2820fcf5ef2aSThomas Huth set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i); 2821fcf5ef2aSThomas Huth 2822fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2823fcf5ef2aSThomas Huth break; 2824fcf5ef2aSThomas Huth } 2825fcf5ef2aSThomas Huth } 2826fcf5ef2aSThomas Huth set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0); 2827fcf5ef2aSThomas Huth 2828fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2829fcf5ef2aSThomas Huth 2830fcf5ef2aSThomas Huth if (ox_flag) { 2831efa73196SNikunj A Dadhania cr |= CRF_SO; 2832fcf5ef2aSThomas Huth } 2833fcf5ef2aSThomas Huth 2834fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2835efa73196SNikunj A Dadhania cr = CRF_SO; 2836fcf5ef2aSThomas Huth } 2837fcf5ef2aSThomas Huth 2838fcf5ef2aSThomas Huth *r = ret; 2839fcf5ef2aSThomas Huth 2840fcf5ef2aSThomas Huth return cr; 2841fcf5ef2aSThomas Huth } 2842fcf5ef2aSThomas Huth 2843fcf5ef2aSThomas Huth uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2844fcf5ef2aSThomas Huth { 2845fcf5ef2aSThomas Huth int i; 2846fcf5ef2aSThomas Huth int cr = 0; 2847fcf5ef2aSThomas Huth int invalid = 0; 2848fcf5ef2aSThomas Huth int zone_digit = 0; 2849fcf5ef2aSThomas Huth int zone_lead = ps ? 0xF : 0x3; 2850fcf5ef2aSThomas Huth int digit = 0; 2851fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2852fcf5ef2aSThomas Huth int sgnb = b->u8[BCD_DIG_BYTE(0)] >> 4; 2853fcf5ef2aSThomas Huth 2854fcf5ef2aSThomas Huth if (unlikely((sgnb < 0xA) && ps)) { 2855fcf5ef2aSThomas Huth invalid = 1; 2856fcf5ef2aSThomas Huth } 2857fcf5ef2aSThomas Huth 2858fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2859365206aeSJose Ricardo Ziviani zone_digit = i ? b->u8[BCD_DIG_BYTE(i * 2)] >> 4 : zone_lead; 2860fcf5ef2aSThomas Huth digit = b->u8[BCD_DIG_BYTE(i * 2)] & 0xF; 2861fcf5ef2aSThomas Huth if (unlikely(zone_digit != zone_lead || digit > 0x9)) { 2862fcf5ef2aSThomas Huth invalid = 1; 2863fcf5ef2aSThomas Huth break; 2864fcf5ef2aSThomas Huth } 2865fcf5ef2aSThomas Huth 2866fcf5ef2aSThomas Huth bcd_put_digit(&ret, digit, i + 1); 2867fcf5ef2aSThomas Huth } 2868fcf5ef2aSThomas Huth 2869fcf5ef2aSThomas Huth if ((ps && (sgnb == 0xB || sgnb == 0xD)) || 2870fcf5ef2aSThomas Huth (!ps && (sgnb & 0x4))) { 2871fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2872fcf5ef2aSThomas Huth } else { 2873fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0); 2874fcf5ef2aSThomas Huth } 2875fcf5ef2aSThomas Huth 2876fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2877fcf5ef2aSThomas Huth 2878fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2879efa73196SNikunj A Dadhania cr = CRF_SO; 2880fcf5ef2aSThomas Huth } 2881fcf5ef2aSThomas Huth 2882fcf5ef2aSThomas Huth *r = ret; 2883fcf5ef2aSThomas Huth 2884fcf5ef2aSThomas Huth return cr; 2885fcf5ef2aSThomas Huth } 2886fcf5ef2aSThomas Huth 2887fcf5ef2aSThomas Huth uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2888fcf5ef2aSThomas Huth { 2889fcf5ef2aSThomas Huth int i; 2890fcf5ef2aSThomas Huth int cr = 0; 2891fcf5ef2aSThomas Huth uint8_t digit = 0; 2892fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2893fcf5ef2aSThomas Huth int zone_lead = (ps) ? 0xF0 : 0x30; 2894fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2895fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2896fcf5ef2aSThomas Huth 2897fcf5ef2aSThomas Huth int ox_flag = ((b->u64[HI_IDX] >> 4) != 0); 2898fcf5ef2aSThomas Huth 2899fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2900fcf5ef2aSThomas Huth digit = bcd_get_digit(b, i + 1, &invalid); 2901fcf5ef2aSThomas Huth 2902fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2903fcf5ef2aSThomas Huth break; 2904fcf5ef2aSThomas Huth } 2905fcf5ef2aSThomas Huth 2906fcf5ef2aSThomas Huth ret.u8[BCD_DIG_BYTE(i * 2)] = zone_lead + digit; 2907fcf5ef2aSThomas Huth } 2908fcf5ef2aSThomas Huth 2909fcf5ef2aSThomas Huth if (ps) { 2910fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1); 2911fcf5ef2aSThomas Huth } else { 2912fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1); 2913fcf5ef2aSThomas Huth } 2914fcf5ef2aSThomas Huth 2915fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2916fcf5ef2aSThomas Huth 2917fcf5ef2aSThomas Huth if (ox_flag) { 2918efa73196SNikunj A Dadhania cr |= CRF_SO; 2919fcf5ef2aSThomas Huth } 2920fcf5ef2aSThomas Huth 2921fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2922efa73196SNikunj A Dadhania cr = CRF_SO; 2923fcf5ef2aSThomas Huth } 2924fcf5ef2aSThomas Huth 2925fcf5ef2aSThomas Huth *r = ret; 2926fcf5ef2aSThomas Huth 2927fcf5ef2aSThomas Huth return cr; 2928fcf5ef2aSThomas Huth } 2929fcf5ef2aSThomas Huth 2930a406c058SJose Ricardo Ziviani uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2931a406c058SJose Ricardo Ziviani { 2932a406c058SJose Ricardo Ziviani int i; 2933a406c058SJose Ricardo Ziviani int cr = 0; 2934a406c058SJose Ricardo Ziviani uint64_t lo_value; 2935a406c058SJose Ricardo Ziviani uint64_t hi_value; 2936a406c058SJose Ricardo Ziviani ppc_avr_t ret = { .u64 = { 0, 0 } }; 2937a406c058SJose Ricardo Ziviani 2938a406c058SJose Ricardo Ziviani if (b->s64[HI_IDX] < 0) { 2939a406c058SJose Ricardo Ziviani lo_value = -b->s64[LO_IDX]; 2940a406c058SJose Ricardo Ziviani hi_value = ~b->u64[HI_IDX] + !lo_value; 2941a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, 0xD, 0); 2942a406c058SJose Ricardo Ziviani } else { 2943a406c058SJose Ricardo Ziviani lo_value = b->u64[LO_IDX]; 2944a406c058SJose Ricardo Ziviani hi_value = b->u64[HI_IDX]; 2945a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0); 2946a406c058SJose Ricardo Ziviani } 2947a406c058SJose Ricardo Ziviani 2948a406c058SJose Ricardo Ziviani if (divu128(&lo_value, &hi_value, 1000000000000000ULL) || 2949a406c058SJose Ricardo Ziviani lo_value > 9999999999999999ULL) { 2950a406c058SJose Ricardo Ziviani cr = CRF_SO; 2951a406c058SJose Ricardo Ziviani } 2952a406c058SJose Ricardo Ziviani 2953a406c058SJose Ricardo Ziviani for (i = 1; i < 16; hi_value /= 10, i++) { 2954a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, hi_value % 10, i); 2955a406c058SJose Ricardo Ziviani } 2956a406c058SJose Ricardo Ziviani 2957a406c058SJose Ricardo Ziviani for (; i < 32; lo_value /= 10, i++) { 2958a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, lo_value % 10, i); 2959a406c058SJose Ricardo Ziviani } 2960a406c058SJose Ricardo Ziviani 2961a406c058SJose Ricardo Ziviani cr |= bcd_cmp_zero(&ret); 2962a406c058SJose Ricardo Ziviani 2963a406c058SJose Ricardo Ziviani *r = ret; 2964a406c058SJose Ricardo Ziviani 2965a406c058SJose Ricardo Ziviani return cr; 2966a406c058SJose Ricardo Ziviani } 2967a406c058SJose Ricardo Ziviani 2968c85bc7ddSJose Ricardo Ziviani uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2969c85bc7ddSJose Ricardo Ziviani { 2970c85bc7ddSJose Ricardo Ziviani uint8_t i; 2971c85bc7ddSJose Ricardo Ziviani int cr; 2972c85bc7ddSJose Ricardo Ziviani uint64_t carry; 2973c85bc7ddSJose Ricardo Ziviani uint64_t unused; 2974c85bc7ddSJose Ricardo Ziviani uint64_t lo_value; 2975c85bc7ddSJose Ricardo Ziviani uint64_t hi_value = 0; 2976c85bc7ddSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2977c85bc7ddSJose Ricardo Ziviani int invalid = (sgnb == 0); 2978c85bc7ddSJose Ricardo Ziviani 2979c85bc7ddSJose Ricardo Ziviani lo_value = bcd_get_digit(b, 31, &invalid); 2980c85bc7ddSJose Ricardo Ziviani for (i = 30; i > 0; i--) { 2981c85bc7ddSJose Ricardo Ziviani mulu64(&lo_value, &carry, lo_value, 10ULL); 2982c85bc7ddSJose Ricardo Ziviani mulu64(&hi_value, &unused, hi_value, 10ULL); 2983c85bc7ddSJose Ricardo Ziviani lo_value += bcd_get_digit(b, i, &invalid); 2984c85bc7ddSJose Ricardo Ziviani hi_value += carry; 2985c85bc7ddSJose Ricardo Ziviani 2986c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2987c85bc7ddSJose Ricardo Ziviani break; 2988c85bc7ddSJose Ricardo Ziviani } 2989c85bc7ddSJose Ricardo Ziviani } 2990c85bc7ddSJose Ricardo Ziviani 2991c85bc7ddSJose Ricardo Ziviani if (sgnb == -1) { 2992c85bc7ddSJose Ricardo Ziviani r->s64[LO_IDX] = -lo_value; 2993c85bc7ddSJose Ricardo Ziviani r->s64[HI_IDX] = ~hi_value + !r->s64[LO_IDX]; 2994c85bc7ddSJose Ricardo Ziviani } else { 2995c85bc7ddSJose Ricardo Ziviani r->s64[LO_IDX] = lo_value; 2996c85bc7ddSJose Ricardo Ziviani r->s64[HI_IDX] = hi_value; 2997c85bc7ddSJose Ricardo Ziviani } 2998c85bc7ddSJose Ricardo Ziviani 2999c85bc7ddSJose Ricardo Ziviani cr = bcd_cmp_zero(b); 3000c85bc7ddSJose Ricardo Ziviani 3001c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 3002c85bc7ddSJose Ricardo Ziviani cr = CRF_SO; 3003c85bc7ddSJose Ricardo Ziviani } 3004c85bc7ddSJose Ricardo Ziviani 3005c85bc7ddSJose Ricardo Ziviani return cr; 3006c85bc7ddSJose Ricardo Ziviani } 3007c85bc7ddSJose Ricardo Ziviani 3008c3025c3bSJose Ricardo Ziviani uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 3009c3025c3bSJose Ricardo Ziviani { 3010c3025c3bSJose Ricardo Ziviani int i; 3011c3025c3bSJose Ricardo Ziviani int invalid = 0; 3012c3025c3bSJose Ricardo Ziviani 3013c3025c3bSJose Ricardo Ziviani if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) { 3014c3025c3bSJose Ricardo Ziviani return CRF_SO; 3015c3025c3bSJose Ricardo Ziviani } 3016c3025c3bSJose Ricardo Ziviani 3017c3025c3bSJose Ricardo Ziviani *r = *a; 3018c3025c3bSJose Ricardo Ziviani bcd_put_digit(r, b->u8[BCD_DIG_BYTE(0)] & 0xF, 0); 3019c3025c3bSJose Ricardo Ziviani 3020c3025c3bSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 3021c3025c3bSJose Ricardo Ziviani bcd_get_digit(a, i, &invalid); 3022c3025c3bSJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 3023c3025c3bSJose Ricardo Ziviani if (unlikely(invalid)) { 3024c3025c3bSJose Ricardo Ziviani return CRF_SO; 3025c3025c3bSJose Ricardo Ziviani } 3026c3025c3bSJose Ricardo Ziviani } 3027c3025c3bSJose Ricardo Ziviani 3028c3025c3bSJose Ricardo Ziviani return bcd_cmp_zero(r); 3029c3025c3bSJose Ricardo Ziviani } 3030c3025c3bSJose Ricardo Ziviani 3031466a3f9cSJose Ricardo Ziviani uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 3032466a3f9cSJose Ricardo Ziviani { 3033466a3f9cSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 3034466a3f9cSJose Ricardo Ziviani 3035466a3f9cSJose Ricardo Ziviani *r = *b; 3036466a3f9cSJose Ricardo Ziviani bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0); 3037466a3f9cSJose Ricardo Ziviani 3038071663dfSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 3039466a3f9cSJose Ricardo Ziviani return CRF_SO; 3040466a3f9cSJose Ricardo Ziviani } 3041466a3f9cSJose Ricardo Ziviani 3042466a3f9cSJose Ricardo Ziviani return bcd_cmp_zero(r); 3043466a3f9cSJose Ricardo Ziviani } 3044466a3f9cSJose Ricardo Ziviani 3045e04797f7SJose Ricardo Ziviani uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 3046e04797f7SJose Ricardo Ziviani { 3047e04797f7SJose Ricardo Ziviani int cr; 3048e04797f7SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 3049e04797f7SJose Ricardo Ziviani int i = a->s8[7]; 3050e04797f7SJose Ricardo Ziviani #else 3051e04797f7SJose Ricardo Ziviani int i = a->s8[8]; 3052e04797f7SJose Ricardo Ziviani #endif 3053e04797f7SJose Ricardo Ziviani bool ox_flag = false; 3054e04797f7SJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 3055e04797f7SJose Ricardo Ziviani ppc_avr_t ret = *b; 3056e04797f7SJose Ricardo Ziviani ret.u64[LO_IDX] &= ~0xf; 3057e04797f7SJose Ricardo Ziviani 3058e04797f7SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 3059e04797f7SJose Ricardo Ziviani return CRF_SO; 3060e04797f7SJose Ricardo Ziviani } 3061e04797f7SJose Ricardo Ziviani 3062e04797f7SJose Ricardo Ziviani if (unlikely(i > 31)) { 3063e04797f7SJose Ricardo Ziviani i = 31; 3064e04797f7SJose Ricardo Ziviani } else if (unlikely(i < -31)) { 3065e04797f7SJose Ricardo Ziviani i = -31; 3066e04797f7SJose Ricardo Ziviani } 3067e04797f7SJose Ricardo Ziviani 3068e04797f7SJose Ricardo Ziviani if (i > 0) { 3069e04797f7SJose Ricardo Ziviani ulshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], i * 4, &ox_flag); 3070e04797f7SJose Ricardo Ziviani } else { 3071e04797f7SJose Ricardo Ziviani urshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], -i * 4); 3072e04797f7SJose Ricardo Ziviani } 3073e04797f7SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 3074e04797f7SJose Ricardo Ziviani 3075e04797f7SJose Ricardo Ziviani *r = ret; 3076e04797f7SJose Ricardo Ziviani 3077e04797f7SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 3078e04797f7SJose Ricardo Ziviani if (ox_flag) { 3079e04797f7SJose Ricardo Ziviani cr |= CRF_SO; 3080e04797f7SJose Ricardo Ziviani } 3081e04797f7SJose Ricardo Ziviani 3082e04797f7SJose Ricardo Ziviani return cr; 3083e04797f7SJose Ricardo Ziviani } 3084e04797f7SJose Ricardo Ziviani 3085a49a95e9SJose Ricardo Ziviani uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 3086a49a95e9SJose Ricardo Ziviani { 3087a49a95e9SJose Ricardo Ziviani int cr; 3088a49a95e9SJose Ricardo Ziviani int i; 3089a49a95e9SJose Ricardo Ziviani int invalid = 0; 3090a49a95e9SJose Ricardo Ziviani bool ox_flag = false; 3091a49a95e9SJose Ricardo Ziviani ppc_avr_t ret = *b; 3092a49a95e9SJose Ricardo Ziviani 3093a49a95e9SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 3094a49a95e9SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 3095a49a95e9SJose Ricardo Ziviani 3096a49a95e9SJose Ricardo Ziviani if (unlikely(invalid)) { 3097a49a95e9SJose Ricardo Ziviani return CRF_SO; 3098a49a95e9SJose Ricardo Ziviani } 3099a49a95e9SJose Ricardo Ziviani } 3100a49a95e9SJose Ricardo Ziviani 3101a49a95e9SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 3102a49a95e9SJose Ricardo Ziviani i = a->s8[7]; 3103a49a95e9SJose Ricardo Ziviani #else 3104a49a95e9SJose Ricardo Ziviani i = a->s8[8]; 3105a49a95e9SJose Ricardo Ziviani #endif 3106a49a95e9SJose Ricardo Ziviani if (i >= 32) { 3107a49a95e9SJose Ricardo Ziviani ox_flag = true; 3108a49a95e9SJose Ricardo Ziviani ret.u64[LO_IDX] = ret.u64[HI_IDX] = 0; 3109a49a95e9SJose Ricardo Ziviani } else if (i <= -32) { 3110a49a95e9SJose Ricardo Ziviani ret.u64[LO_IDX] = ret.u64[HI_IDX] = 0; 3111a49a95e9SJose Ricardo Ziviani } else if (i > 0) { 3112a49a95e9SJose Ricardo Ziviani ulshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], i * 4, &ox_flag); 3113a49a95e9SJose Ricardo Ziviani } else { 3114a49a95e9SJose Ricardo Ziviani urshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], -i * 4); 3115a49a95e9SJose Ricardo Ziviani } 3116a49a95e9SJose Ricardo Ziviani *r = ret; 3117a49a95e9SJose Ricardo Ziviani 3118a49a95e9SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 3119a49a95e9SJose Ricardo Ziviani if (ox_flag) { 3120a49a95e9SJose Ricardo Ziviani cr |= CRF_SO; 3121a49a95e9SJose Ricardo Ziviani } 3122a49a95e9SJose Ricardo Ziviani 3123a49a95e9SJose Ricardo Ziviani return cr; 3124a49a95e9SJose Ricardo Ziviani } 3125a49a95e9SJose Ricardo Ziviani 3126a54238adSJose Ricardo Ziviani uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 3127a54238adSJose Ricardo Ziviani { 3128a54238adSJose Ricardo Ziviani int cr; 3129a54238adSJose Ricardo Ziviani int unused = 0; 3130a54238adSJose Ricardo Ziviani int invalid = 0; 3131a54238adSJose Ricardo Ziviani bool ox_flag = false; 3132a54238adSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 3133a54238adSJose Ricardo Ziviani ppc_avr_t ret = *b; 3134a54238adSJose Ricardo Ziviani ret.u64[LO_IDX] &= ~0xf; 3135a54238adSJose Ricardo Ziviani 3136a54238adSJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 3137a54238adSJose Ricardo Ziviani int i = a->s8[7]; 3138a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0, 0x10 } }; 3139a54238adSJose Ricardo Ziviani #else 3140a54238adSJose Ricardo Ziviani int i = a->s8[8]; 3141a54238adSJose Ricardo Ziviani ppc_avr_t bcd_one = { .u64 = { 0x10, 0 } }; 3142a54238adSJose Ricardo Ziviani #endif 3143a54238adSJose Ricardo Ziviani 3144a54238adSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 3145a54238adSJose Ricardo Ziviani return CRF_SO; 3146a54238adSJose Ricardo Ziviani } 3147a54238adSJose Ricardo Ziviani 3148a54238adSJose Ricardo Ziviani if (unlikely(i > 31)) { 3149a54238adSJose Ricardo Ziviani i = 31; 3150a54238adSJose Ricardo Ziviani } else if (unlikely(i < -31)) { 3151a54238adSJose Ricardo Ziviani i = -31; 3152a54238adSJose Ricardo Ziviani } 3153a54238adSJose Ricardo Ziviani 3154a54238adSJose Ricardo Ziviani if (i > 0) { 3155a54238adSJose Ricardo Ziviani ulshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], i * 4, &ox_flag); 3156a54238adSJose Ricardo Ziviani } else { 3157a54238adSJose Ricardo Ziviani urshift(&ret.u64[LO_IDX], &ret.u64[HI_IDX], -i * 4); 3158a54238adSJose Ricardo Ziviani 3159a54238adSJose Ricardo Ziviani if (bcd_get_digit(&ret, 0, &invalid) >= 5) { 3160a54238adSJose Ricardo Ziviani bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused); 3161a54238adSJose Ricardo Ziviani } 3162a54238adSJose Ricardo Ziviani } 3163a54238adSJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 3164a54238adSJose Ricardo Ziviani 3165a54238adSJose Ricardo Ziviani cr = bcd_cmp_zero(&ret); 3166a54238adSJose Ricardo Ziviani if (ox_flag) { 3167a54238adSJose Ricardo Ziviani cr |= CRF_SO; 3168a54238adSJose Ricardo Ziviani } 3169a54238adSJose Ricardo Ziviani *r = ret; 3170a54238adSJose Ricardo Ziviani 3171a54238adSJose Ricardo Ziviani return cr; 3172a54238adSJose Ricardo Ziviani } 3173a54238adSJose Ricardo Ziviani 317431bc4d11SJose Ricardo Ziviani uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 317531bc4d11SJose Ricardo Ziviani { 317631bc4d11SJose Ricardo Ziviani uint64_t mask; 317731bc4d11SJose Ricardo Ziviani uint32_t ox_flag = 0; 317831bc4d11SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 317931bc4d11SJose Ricardo Ziviani int i = a->s16[3] + 1; 318031bc4d11SJose Ricardo Ziviani #else 318131bc4d11SJose Ricardo Ziviani int i = a->s16[4] + 1; 318231bc4d11SJose Ricardo Ziviani #endif 318331bc4d11SJose Ricardo Ziviani ppc_avr_t ret = *b; 318431bc4d11SJose Ricardo Ziviani 318531bc4d11SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 318631bc4d11SJose Ricardo Ziviani return CRF_SO; 318731bc4d11SJose Ricardo Ziviani } 318831bc4d11SJose Ricardo Ziviani 318931bc4d11SJose Ricardo Ziviani if (i > 16 && i < 32) { 319031bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 319131bc4d11SJose Ricardo Ziviani if (ret.u64[HI_IDX] & ~mask) { 319231bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 319331bc4d11SJose Ricardo Ziviani } 319431bc4d11SJose Ricardo Ziviani 319531bc4d11SJose Ricardo Ziviani ret.u64[HI_IDX] &= mask; 319631bc4d11SJose Ricardo Ziviani } else if (i >= 0 && i <= 16) { 319731bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 319831bc4d11SJose Ricardo Ziviani if (ret.u64[HI_IDX] || (ret.u64[LO_IDX] & ~mask)) { 319931bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 320031bc4d11SJose Ricardo Ziviani } 320131bc4d11SJose Ricardo Ziviani 320231bc4d11SJose Ricardo Ziviani ret.u64[LO_IDX] &= mask; 320331bc4d11SJose Ricardo Ziviani ret.u64[HI_IDX] = 0; 320431bc4d11SJose Ricardo Ziviani } 320531bc4d11SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0); 320631bc4d11SJose Ricardo Ziviani *r = ret; 320731bc4d11SJose Ricardo Ziviani 320831bc4d11SJose Ricardo Ziviani return bcd_cmp_zero(&ret) | ox_flag; 320931bc4d11SJose Ricardo Ziviani } 321031bc4d11SJose Ricardo Ziviani 32115c32e2e4SJose Ricardo Ziviani uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 32125c32e2e4SJose Ricardo Ziviani { 32135c32e2e4SJose Ricardo Ziviani int i; 32145c32e2e4SJose Ricardo Ziviani uint64_t mask; 32155c32e2e4SJose Ricardo Ziviani uint32_t ox_flag = 0; 32165c32e2e4SJose Ricardo Ziviani int invalid = 0; 32175c32e2e4SJose Ricardo Ziviani ppc_avr_t ret = *b; 32185c32e2e4SJose Ricardo Ziviani 32195c32e2e4SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 32205c32e2e4SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 32215c32e2e4SJose Ricardo Ziviani 32225c32e2e4SJose Ricardo Ziviani if (unlikely(invalid)) { 32235c32e2e4SJose Ricardo Ziviani return CRF_SO; 32245c32e2e4SJose Ricardo Ziviani } 32255c32e2e4SJose Ricardo Ziviani } 32265c32e2e4SJose Ricardo Ziviani 32275c32e2e4SJose Ricardo Ziviani #if defined(HOST_WORDS_BIGENDIAN) 32285c32e2e4SJose Ricardo Ziviani i = a->s16[3]; 32295c32e2e4SJose Ricardo Ziviani #else 32305c32e2e4SJose Ricardo Ziviani i = a->s16[4]; 32315c32e2e4SJose Ricardo Ziviani #endif 32325c32e2e4SJose Ricardo Ziviani if (i > 16 && i < 33) { 32335c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 32345c32e2e4SJose Ricardo Ziviani if (ret.u64[HI_IDX] & ~mask) { 32355c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 32365c32e2e4SJose Ricardo Ziviani } 32375c32e2e4SJose Ricardo Ziviani 32385c32e2e4SJose Ricardo Ziviani ret.u64[HI_IDX] &= mask; 32395c32e2e4SJose Ricardo Ziviani } else if (i > 0 && i <= 16) { 32405c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 32415c32e2e4SJose Ricardo Ziviani if (ret.u64[HI_IDX] || (ret.u64[LO_IDX] & ~mask)) { 32425c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 32435c32e2e4SJose Ricardo Ziviani } 32445c32e2e4SJose Ricardo Ziviani 32455c32e2e4SJose Ricardo Ziviani ret.u64[LO_IDX] &= mask; 32465c32e2e4SJose Ricardo Ziviani ret.u64[HI_IDX] = 0; 32475c32e2e4SJose Ricardo Ziviani } else if (i == 0) { 32485c32e2e4SJose Ricardo Ziviani if (ret.u64[HI_IDX] || ret.u64[LO_IDX]) { 32495c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 32505c32e2e4SJose Ricardo Ziviani } 32515c32e2e4SJose Ricardo Ziviani ret.u64[HI_IDX] = ret.u64[LO_IDX] = 0; 32525c32e2e4SJose Ricardo Ziviani } 32535c32e2e4SJose Ricardo Ziviani 32545c32e2e4SJose Ricardo Ziviani *r = ret; 32555c32e2e4SJose Ricardo Ziviani if (r->u64[HI_IDX] == 0 && r->u64[LO_IDX] == 0) { 32565c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_EQ; 32575c32e2e4SJose Ricardo Ziviani } 32585c32e2e4SJose Ricardo Ziviani 32595c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_GT; 32605c32e2e4SJose Ricardo Ziviani } 32615c32e2e4SJose Ricardo Ziviani 3262fcf5ef2aSThomas Huth void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a) 3263fcf5ef2aSThomas Huth { 3264fcf5ef2aSThomas Huth int i; 3265fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3266fcf5ef2aSThomas Huth r->u8[i] = AES_sbox[a->u8[i]]; 3267fcf5ef2aSThomas Huth } 3268fcf5ef2aSThomas Huth } 3269fcf5ef2aSThomas Huth 3270fcf5ef2aSThomas Huth void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3271fcf5ef2aSThomas Huth { 3272fcf5ef2aSThomas Huth ppc_avr_t result; 3273fcf5ef2aSThomas Huth int i; 3274fcf5ef2aSThomas Huth 3275fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 3276*2dea57dbSMark Cave-Ayland result.VsrW(i) = b->VsrW(i) ^ 3277*2dea57dbSMark Cave-Ayland (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^ 3278*2dea57dbSMark Cave-Ayland AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^ 3279*2dea57dbSMark Cave-Ayland AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^ 3280*2dea57dbSMark Cave-Ayland AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]); 3281fcf5ef2aSThomas Huth } 3282fcf5ef2aSThomas Huth *r = result; 3283fcf5ef2aSThomas Huth } 3284fcf5ef2aSThomas Huth 3285fcf5ef2aSThomas Huth void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3286fcf5ef2aSThomas Huth { 3287fcf5ef2aSThomas Huth ppc_avr_t result; 3288fcf5ef2aSThomas Huth int i; 3289fcf5ef2aSThomas Huth 3290fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3291*2dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]); 3292fcf5ef2aSThomas Huth } 3293fcf5ef2aSThomas Huth *r = result; 3294fcf5ef2aSThomas Huth } 3295fcf5ef2aSThomas Huth 3296fcf5ef2aSThomas Huth void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3297fcf5ef2aSThomas Huth { 3298fcf5ef2aSThomas Huth /* This differs from what is written in ISA V2.07. The RTL is */ 3299fcf5ef2aSThomas Huth /* incorrect and will be fixed in V2.07B. */ 3300fcf5ef2aSThomas Huth int i; 3301fcf5ef2aSThomas Huth ppc_avr_t tmp; 3302fcf5ef2aSThomas Huth 3303fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3304*2dea57dbSMark Cave-Ayland tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])]; 3305fcf5ef2aSThomas Huth } 3306fcf5ef2aSThomas Huth 3307fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 3308*2dea57dbSMark Cave-Ayland r->VsrW(i) = 3309*2dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 0)][0] ^ 3310*2dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 1)][1] ^ 3311*2dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 2)][2] ^ 3312*2dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 3)][3]; 3313fcf5ef2aSThomas Huth } 3314fcf5ef2aSThomas Huth } 3315fcf5ef2aSThomas Huth 3316fcf5ef2aSThomas Huth void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 3317fcf5ef2aSThomas Huth { 3318fcf5ef2aSThomas Huth ppc_avr_t result; 3319fcf5ef2aSThomas Huth int i; 3320fcf5ef2aSThomas Huth 3321fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3322*2dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]); 3323fcf5ef2aSThomas Huth } 3324fcf5ef2aSThomas Huth *r = result; 3325fcf5ef2aSThomas Huth } 3326fcf5ef2aSThomas Huth 3327fcf5ef2aSThomas Huth #define ROTRu32(v, n) (((v) >> (n)) | ((v) << (32-n))) 3328fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 3329fcf5ef2aSThomas Huth #define EL_IDX(i) (i) 3330fcf5ef2aSThomas Huth #else 3331fcf5ef2aSThomas Huth #define EL_IDX(i) (3 - (i)) 3332fcf5ef2aSThomas Huth #endif 3333fcf5ef2aSThomas Huth 3334fcf5ef2aSThomas Huth void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3335fcf5ef2aSThomas Huth { 3336fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3337fcf5ef2aSThomas Huth int six = st_six & 0xF; 3338fcf5ef2aSThomas Huth int i; 3339fcf5ef2aSThomas Huth 3340fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 3341fcf5ef2aSThomas Huth if (st == 0) { 3342fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 3343fcf5ef2aSThomas Huth r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 7) ^ 3344fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 18) ^ 3345fcf5ef2aSThomas Huth (a->u32[EL_IDX(i)] >> 3); 3346fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 3347fcf5ef2aSThomas Huth r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 17) ^ 3348fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 19) ^ 3349fcf5ef2aSThomas Huth (a->u32[EL_IDX(i)] >> 10); 3350fcf5ef2aSThomas Huth } 3351fcf5ef2aSThomas Huth } else { /* st == 1 */ 3352fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 3353fcf5ef2aSThomas Huth r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 2) ^ 3354fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 13) ^ 3355fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 22); 3356fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 3357fcf5ef2aSThomas Huth r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 6) ^ 3358fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 11) ^ 3359fcf5ef2aSThomas Huth ROTRu32(a->u32[EL_IDX(i)], 25); 3360fcf5ef2aSThomas Huth } 3361fcf5ef2aSThomas Huth } 3362fcf5ef2aSThomas Huth } 3363fcf5ef2aSThomas Huth } 3364fcf5ef2aSThomas Huth 3365fcf5ef2aSThomas Huth #undef ROTRu32 3366fcf5ef2aSThomas Huth #undef EL_IDX 3367fcf5ef2aSThomas Huth 3368fcf5ef2aSThomas Huth #define ROTRu64(v, n) (((v) >> (n)) | ((v) << (64-n))) 3369fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 3370fcf5ef2aSThomas Huth #define EL_IDX(i) (i) 3371fcf5ef2aSThomas Huth #else 3372fcf5ef2aSThomas Huth #define EL_IDX(i) (1 - (i)) 3373fcf5ef2aSThomas Huth #endif 3374fcf5ef2aSThomas Huth 3375fcf5ef2aSThomas Huth void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 3376fcf5ef2aSThomas Huth { 3377fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 3378fcf5ef2aSThomas Huth int six = st_six & 0xF; 3379fcf5ef2aSThomas Huth int i; 3380fcf5ef2aSThomas Huth 3381fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 3382fcf5ef2aSThomas Huth if (st == 0) { 3383fcf5ef2aSThomas Huth if ((six & (0x8 >> (2*i))) == 0) { 3384fcf5ef2aSThomas Huth r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 1) ^ 3385fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 8) ^ 3386fcf5ef2aSThomas Huth (a->u64[EL_IDX(i)] >> 7); 3387fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 3388fcf5ef2aSThomas Huth r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 19) ^ 3389fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 61) ^ 3390fcf5ef2aSThomas Huth (a->u64[EL_IDX(i)] >> 6); 3391fcf5ef2aSThomas Huth } 3392fcf5ef2aSThomas Huth } else { /* st == 1 */ 3393fcf5ef2aSThomas Huth if ((six & (0x8 >> (2*i))) == 0) { 3394fcf5ef2aSThomas Huth r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 28) ^ 3395fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 34) ^ 3396fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 39); 3397fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 3398fcf5ef2aSThomas Huth r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 14) ^ 3399fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 18) ^ 3400fcf5ef2aSThomas Huth ROTRu64(a->u64[EL_IDX(i)], 41); 3401fcf5ef2aSThomas Huth } 3402fcf5ef2aSThomas Huth } 3403fcf5ef2aSThomas Huth } 3404fcf5ef2aSThomas Huth } 3405fcf5ef2aSThomas Huth 3406fcf5ef2aSThomas Huth #undef ROTRu64 3407fcf5ef2aSThomas Huth #undef EL_IDX 3408fcf5ef2aSThomas Huth 3409fcf5ef2aSThomas Huth void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 3410fcf5ef2aSThomas Huth { 3411fcf5ef2aSThomas Huth ppc_avr_t result; 3412fcf5ef2aSThomas Huth int i; 3413fcf5ef2aSThomas Huth 3414fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 3415fcf5ef2aSThomas Huth int indexA = c->u8[i] >> 4; 3416fcf5ef2aSThomas Huth int indexB = c->u8[i] & 0xF; 3417fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 3418fcf5ef2aSThomas Huth result.u8[i] = a->u8[indexA] ^ b->u8[indexB]; 3419fcf5ef2aSThomas Huth #else 3420fcf5ef2aSThomas Huth result.u8[i] = a->u8[15-indexA] ^ b->u8[15-indexB]; 3421fcf5ef2aSThomas Huth #endif 3422fcf5ef2aSThomas Huth } 3423fcf5ef2aSThomas Huth *r = result; 3424fcf5ef2aSThomas Huth } 3425fcf5ef2aSThomas Huth 3426fcf5ef2aSThomas Huth #undef VECTOR_FOR_INORDER_I 3427fcf5ef2aSThomas Huth #undef HI_IDX 3428fcf5ef2aSThomas Huth #undef LO_IDX 3429fcf5ef2aSThomas Huth 3430fcf5ef2aSThomas Huth /*****************************************************************************/ 3431fcf5ef2aSThomas Huth /* SPE extension helpers */ 3432fcf5ef2aSThomas Huth /* Use a table to make this quicker */ 3433fcf5ef2aSThomas Huth static const uint8_t hbrev[16] = { 3434fcf5ef2aSThomas Huth 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 3435fcf5ef2aSThomas Huth 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, 3436fcf5ef2aSThomas Huth }; 3437fcf5ef2aSThomas Huth 3438fcf5ef2aSThomas Huth static inline uint8_t byte_reverse(uint8_t val) 3439fcf5ef2aSThomas Huth { 3440fcf5ef2aSThomas Huth return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); 3441fcf5ef2aSThomas Huth } 3442fcf5ef2aSThomas Huth 3443fcf5ef2aSThomas Huth static inline uint32_t word_reverse(uint32_t val) 3444fcf5ef2aSThomas Huth { 3445fcf5ef2aSThomas Huth return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | 3446fcf5ef2aSThomas Huth (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); 3447fcf5ef2aSThomas Huth } 3448fcf5ef2aSThomas Huth 3449fcf5ef2aSThomas Huth #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */ 3450fcf5ef2aSThomas Huth target_ulong helper_brinc(target_ulong arg1, target_ulong arg2) 3451fcf5ef2aSThomas Huth { 3452fcf5ef2aSThomas Huth uint32_t a, b, d, mask; 3453fcf5ef2aSThomas Huth 3454fcf5ef2aSThomas Huth mask = UINT32_MAX >> (32 - MASKBITS); 3455fcf5ef2aSThomas Huth a = arg1 & mask; 3456fcf5ef2aSThomas Huth b = arg2 & mask; 3457fcf5ef2aSThomas Huth d = word_reverse(1 + word_reverse(a | ~b)); 3458fcf5ef2aSThomas Huth return (arg1 & ~mask) | (d & b); 3459fcf5ef2aSThomas Huth } 3460fcf5ef2aSThomas Huth 3461fcf5ef2aSThomas Huth uint32_t helper_cntlsw32(uint32_t val) 3462fcf5ef2aSThomas Huth { 3463fcf5ef2aSThomas Huth if (val & 0x80000000) { 3464fcf5ef2aSThomas Huth return clz32(~val); 3465fcf5ef2aSThomas Huth } else { 3466fcf5ef2aSThomas Huth return clz32(val); 3467fcf5ef2aSThomas Huth } 3468fcf5ef2aSThomas Huth } 3469fcf5ef2aSThomas Huth 3470fcf5ef2aSThomas Huth uint32_t helper_cntlzw32(uint32_t val) 3471fcf5ef2aSThomas Huth { 3472fcf5ef2aSThomas Huth return clz32(val); 3473fcf5ef2aSThomas Huth } 3474fcf5ef2aSThomas Huth 3475fcf5ef2aSThomas Huth /* 440 specific */ 3476fcf5ef2aSThomas Huth target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high, 3477fcf5ef2aSThomas Huth target_ulong low, uint32_t update_Rc) 3478fcf5ef2aSThomas Huth { 3479fcf5ef2aSThomas Huth target_ulong mask; 3480fcf5ef2aSThomas Huth int i; 3481fcf5ef2aSThomas Huth 3482fcf5ef2aSThomas Huth i = 1; 3483fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3484fcf5ef2aSThomas Huth if ((high & mask) == 0) { 3485fcf5ef2aSThomas Huth if (update_Rc) { 3486fcf5ef2aSThomas Huth env->crf[0] = 0x4; 3487fcf5ef2aSThomas Huth } 3488fcf5ef2aSThomas Huth goto done; 3489fcf5ef2aSThomas Huth } 3490fcf5ef2aSThomas Huth i++; 3491fcf5ef2aSThomas Huth } 3492fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3493fcf5ef2aSThomas Huth if ((low & mask) == 0) { 3494fcf5ef2aSThomas Huth if (update_Rc) { 3495fcf5ef2aSThomas Huth env->crf[0] = 0x8; 3496fcf5ef2aSThomas Huth } 3497fcf5ef2aSThomas Huth goto done; 3498fcf5ef2aSThomas Huth } 3499fcf5ef2aSThomas Huth i++; 3500fcf5ef2aSThomas Huth } 3501fcf5ef2aSThomas Huth i = 8; 3502fcf5ef2aSThomas Huth if (update_Rc) { 3503fcf5ef2aSThomas Huth env->crf[0] = 0x2; 3504fcf5ef2aSThomas Huth } 3505fcf5ef2aSThomas Huth done: 3506fcf5ef2aSThomas Huth env->xer = (env->xer & ~0x7F) | i; 3507fcf5ef2aSThomas Huth if (update_Rc) { 3508fcf5ef2aSThomas Huth env->crf[0] |= xer_so; 3509fcf5ef2aSThomas Huth } 3510fcf5ef2aSThomas Huth return i; 3511fcf5ef2aSThomas Huth } 3512