Archipelago » qemu

/*

 *  S/390 helper routines

 *

 *  Copyright (c) 2009 Ulrich Hecht

 *  Copyright (c) 2009 Alexander Graf

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "cpu.h"

#include "dyngen-exec.h"

#include "host-utils.h"

#include "helper.h"

#include <string.h>

#include "kvm.h"

#include "qemu-timer.h"

#ifdef CONFIG_KVM

#include <linux/kvm.h>

#endif

#if !defined (CONFIG_USER_ONLY)

#include "sysemu.h"

#endif

/*****************************************************************************/

/* Softmmu support */

#if !defined (CONFIG_USER_ONLY)

#include "softmmu_exec.h"

#define MMUSUFFIX _mmu

#define SHIFT 0

#include "softmmu_template.h"

#define SHIFT 1

#include "softmmu_template.h"

#define SHIFT 2

#include "softmmu_template.h"

#define SHIFT 3

#include "softmmu_template.h"

/* try to fill the TLB and return an exception if error. If retaddr is

   NULL, it means that the function was called in C code (i.e. not

   from generated code or from helper.c) */

/* XXX: fix it to restore all registers */

void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,

              uintptr_t retaddr)

{

    TranslationBlock *tb;

    CPUS390XState *saved_env;

    int ret;

    saved_env = env;

    env = env1;

    ret = cpu_s390x_handle_mmu_fault(env, addr, is_write, mmu_idx);

    if (unlikely(ret != 0)) {

        if (likely(retaddr)) {

            /* now we have a real cpu fault */

            tb = tb_find_pc(retaddr);

            if (likely(tb)) {

                /* the PC is inside the translated code. It means that we have

                   a virtual CPU fault */

                cpu_restore_state(tb, env, retaddr);

            }

        }

        cpu_loop_exit(env);

    }

    env = saved_env;

}

#endif

/* #define DEBUG_HELPER */

#ifdef DEBUG_HELPER

#define HELPER_LOG(x...) qemu_log(x)

#else

#define HELPER_LOG(x...)

#endif

/* raise an exception */

void HELPER(exception)(uint32_t excp)

{

    HELPER_LOG("%s: exception %d\n", __FUNCTION__, excp);

    env->exception_index = excp;

    cpu_loop_exit(env);

}

#ifndef CONFIG_USER_ONLY

static void mvc_fast_memset(CPUS390XState *env, uint32_t l, uint64_t dest,

                            uint8_t byte)

{

    target_phys_addr_t dest_phys;

    target_phys_addr_t len = l;

    void *dest_p;

    uint64_t asc = env->psw.mask & PSW_MASK_ASC;

    int flags;

    if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {

        stb(dest, byte);

        cpu_abort(env, "should never reach here");

    }

    dest_phys |= dest & ~TARGET_PAGE_MASK;

    dest_p = cpu_physical_memory_map(dest_phys, &len, 1);

    memset(dest_p, byte, len);

    cpu_physical_memory_unmap(dest_p, 1, len, len);

}

static void mvc_fast_memmove(CPUS390XState *env, uint32_t l, uint64_t dest,

                             uint64_t src)

{

    target_phys_addr_t dest_phys;

    target_phys_addr_t src_phys;

    target_phys_addr_t len = l;

    void *dest_p;

    void *src_p;

    uint64_t asc = env->psw.mask & PSW_MASK_ASC;

    int flags;

    if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {

        stb(dest, 0);

        cpu_abort(env, "should never reach here");

    }

    dest_phys |= dest & ~TARGET_PAGE_MASK;

    if (mmu_translate(env, src, 0, asc, &src_phys, &flags)) {

        ldub(src);

        cpu_abort(env, "should never reach here");

    }

    src_phys |= src & ~TARGET_PAGE_MASK;

    dest_p = cpu_physical_memory_map(dest_phys, &len, 1);

    src_p = cpu_physical_memory_map(src_phys, &len, 0);

    memmove(dest_p, src_p, len);

    cpu_physical_memory_unmap(dest_p, 1, len, len);

    cpu_physical_memory_unmap(src_p, 0, len, len);

}

#endif

/* and on array */

uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)

{

    int i;

    unsigned char x;

    uint32_t cc = 0;

    HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

               __FUNCTION__, l, dest, src);

    for (i = 0; i <= l; i++) {

        x = ldub(dest + i) & ldub(src + i);

        if (x) {

            cc = 1;

        }

        stb(dest + i, x);

    }

    return cc;

}

/* xor on array */

uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)

{

    int i;

    unsigned char x;

    uint32_t cc = 0;

    HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

               __FUNCTION__, l, dest, src);

#ifndef CONFIG_USER_ONLY

    /* xor with itself is the same as memset(0) */

    if ((l > 32) && (src == dest) &&

        (src & TARGET_PAGE_MASK) == ((src + l) & TARGET_PAGE_MASK)) {

        mvc_fast_memset(env, l + 1, dest, 0);

        return 0;

    }

#else

    if (src == dest) {

        memset(g2h(dest), 0, l + 1);

        return 0;

    }

#endif

    for (i = 0; i <= l; i++) {

        x = ldub(dest + i) ^ ldub(src + i);

        if (x) {

            cc = 1;

        }

        stb(dest + i, x);

    }

    return cc;

}

/* or on array */

uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)

{

    int i;

    unsigned char x;

    uint32_t cc = 0;

    HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

               __FUNCTION__, l, dest, src);

    for (i = 0; i <= l; i++) {

        x = ldub(dest + i) | ldub(src + i);

        if (x) {

            cc = 1;

        }

        stb(dest + i, x);

    }

    return cc;

}

/* memmove */

void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

{

    int i = 0;

    int x = 0;

    uint32_t l_64 = (l + 1) / 8;

    HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

               __FUNCTION__, l, dest, src);

#ifndef CONFIG_USER_ONLY

    if ((l > 32) &&

        (src & TARGET_PAGE_MASK) == ((src + l) & TARGET_PAGE_MASK) &&

        (dest & TARGET_PAGE_MASK) == ((dest + l) & TARGET_PAGE_MASK)) {

        if (dest == (src + 1)) {

            mvc_fast_memset(env, l + 1, dest, ldub(src));

            return;

        } else if ((src & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) {

            mvc_fast_memmove(env, l + 1, dest, src);

            return;

        }

    }

#else

    if (dest == (src + 1)) {

        memset(g2h(dest), ldub(src), l + 1);

        return;

    } else {

        memmove(g2h(dest), g2h(src), l + 1);

        return;

    }

#endif

    /* handle the parts that fit into 8-byte loads/stores */

    if (dest != (src + 1)) {

        for (i = 0; i < l_64; i++) {

            stq(dest + x, ldq(src + x));

            x += 8;

        }

    }

    /* slow version crossing pages with byte accesses */

    for (i = x; i <= l; i++) {

        stb(dest + i, ldub(src + i));

    }

}

/* compare unsigned byte arrays */

uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

{

    int i;

    unsigned char x,y;

    uint32_t cc;

    HELPER_LOG("%s l %d s1 %" PRIx64 " s2 %" PRIx64 "\n",

               __FUNCTION__, l, s1, s2);

    for (i = 0; i <= l; i++) {

        x = ldub(s1 + i);

        y = ldub(s2 + i);

        HELPER_LOG("%02x (%c)/%02x (%c) ", x, x, y, y);

        if (x < y) {

            cc = 1;

            goto done;

        } else if (x > y) {

            cc = 2;

            goto done;

        }

    }

    cc = 0;

done:

    HELPER_LOG("\n");

    return cc;

}

/* compare logical under mask */

uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

{

    uint8_t r,d;

    uint32_t cc;

    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%" PRIx64 "\n", __FUNCTION__, r1,

               mask, addr);

    cc = 0;

    while (mask) {

        if (mask & 8) {

            d = ldub(addr);

            r = (r1 & 0xff000000UL) >> 24;

            HELPER_LOG("mask 0x%x %02x/%02x (0x%" PRIx64 ") ", mask, r, d,

                        addr);

            if (r < d) {

                cc = 1;

                break;

            } else if (r > d) {

                cc = 2;

                break;

            }

            addr++;

        }

        mask = (mask << 1) & 0xf;

        r1 <<= 8;

    }

    HELPER_LOG("\n");

    return cc;

}

/* store character under mask */

void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)

{

    uint8_t r;

    HELPER_LOG("%s: r1 0x%x mask 0x%x addr 0x%lx\n", __FUNCTION__, r1, mask,

               addr);

    while (mask) {

        if (mask & 8) {

            r = (r1 & 0xff000000UL) >> 24;

            stb(addr, r);

            HELPER_LOG("mask 0x%x %02x (0x%lx) ", mask, r, addr);

            addr++;

        }

        mask = (mask << 1) & 0xf;

        r1 <<= 8;

    }

    HELPER_LOG("\n");

}

/* 64/64 -> 128 unsigned multiplication */

void HELPER(mlg)(uint32_t r1, uint64_t v2)

{

#if HOST_LONG_BITS == 64 && defined(__GNUC__)

    /* assuming 64-bit hosts have __uint128_t */

    __uint128_t res = (__uint128_t)env->regs[r1 + 1];

    res *= (__uint128_t)v2;

    env->regs[r1] = (uint64_t)(res >> 64);

    env->regs[r1 + 1] = (uint64_t)res;

#else

    mulu64(&env->regs[r1 + 1], &env->regs[r1], env->regs[r1 + 1], v2);

#endif

}

/* 128 -> 64/64 unsigned division */

void HELPER(dlg)(uint32_t r1, uint64_t v2)

{

    uint64_t divisor = v2;

    if (!env->regs[r1]) {

        /* 64 -> 64/64 case */

        env->regs[r1] = env->regs[r1+1] % divisor;

        env->regs[r1+1] = env->regs[r1+1] / divisor;

        return;

    } else {

#if HOST_LONG_BITS == 64 && defined(__GNUC__)

        /* assuming 64-bit hosts have __uint128_t */

        __uint128_t dividend = (((__uint128_t)env->regs[r1]) << 64) |

                               (env->regs[r1+1]);

        __uint128_t quotient = dividend / divisor;

        env->regs[r1+1] = quotient;

        __uint128_t remainder = dividend % divisor;

        env->regs[r1] = remainder;

#else

        /* 32-bit hosts would need special wrapper functionality - just abort if

           we encounter such a case; it's very unlikely anyways. */

        cpu_abort(env, "128 -> 64/64 division not implemented\n");

#endif

    }

}

static inline uint64_t get_address(int x2, int b2, int d2)

{

    uint64_t r = d2;

    if (x2) {

        r += env->regs[x2];

    }

    if (b2) {

        r += env->regs[b2];

    }

    /* 31-Bit mode */

    if (!(env->psw.mask & PSW_MASK_64)) {

        r &= 0x7fffffff;

    }

    return r;

}

static inline uint64_t get_address_31fix(int reg)

{

    uint64_t r = env->regs[reg];

    /* 31-Bit mode */

    if (!(env->psw.mask & PSW_MASK_64)) {

        r &= 0x7fffffff;

    }

    return r;

}

/* search string (c is byte to search, r2 is string, r1 end of string) */

uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)

{

    uint64_t i;

    uint32_t cc = 2;

    uint64_t str = get_address_31fix(r2);

    uint64_t end = get_address_31fix(r1);

    HELPER_LOG("%s: c %d *r1 0x%" PRIx64 " *r2 0x%" PRIx64 "\n", __FUNCTION__,

               c, env->regs[r1], env->regs[r2]);

    for (i = str; i != end; i++) {

        if (ldub(i) == c) {

            env->regs[r1] = i;

            cc = 1;

            break;

        }

    }

    return cc;

}

/* unsigned string compare (c is string terminator) */

uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)

{

    uint64_t s1 = get_address_31fix(r1);

    uint64_t s2 = get_address_31fix(r2);

    uint8_t v1, v2;

    uint32_t cc;

    c = c & 0xff;

#ifdef CONFIG_USER_ONLY

    if (!c) {

        HELPER_LOG("%s: comparing '%s' and '%s'\n",

                   __FUNCTION__, (char*)g2h(s1), (char*)g2h(s2));

    }

#endif

    for (;;) {

        v1 = ldub(s1);

        v2 = ldub(s2);

        if ((v1 == c || v2 == c) || (v1 != v2)) {

            break;

        }

        s1++;

        s2++;

    }

    if (v1 == v2) {

        cc = 0;

    } else {

        cc = (v1 < v2) ? 1 : 2;

        /* FIXME: 31-bit mode! */

        env->regs[r1] = s1;

        env->regs[r2] = s2;

    }

    return cc;

}

/* move page */

void HELPER(mvpg)(uint64_t r0, uint64_t r1, uint64_t r2)

{

    /* XXX missing r0 handling */

#ifdef CONFIG_USER_ONLY

    int i;

    for (i = 0; i < TARGET_PAGE_SIZE; i++) {

        stb(r1 + i, ldub(r2 + i));

    }

#else

    mvc_fast_memmove(env, TARGET_PAGE_SIZE, r1, r2);

#endif

}

/* string copy (c is string terminator) */

void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)

{

    uint64_t dest = get_address_31fix(r1);

    uint64_t src = get_address_31fix(r2);

    uint8_t v;

    c = c & 0xff;

#ifdef CONFIG_USER_ONLY

    if (!c) {

        HELPER_LOG("%s: copy '%s' to 0x%lx\n", __FUNCTION__, (char*)g2h(src),

                   dest);

    }

#endif

    for (;;) {

        v = ldub(src);

        stb(dest, v);

        if (v == c) {

            break;

        }

        src++;

        dest++;

    }

    env->regs[r1] = dest; /* FIXME: 31-bit mode! */

}

/* compare and swap 64-bit */

uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    /* FIXME: locking? */

    uint32_t cc;

    uint64_t v2 = ldq(a2);

    if (env->regs[r1] == v2) {

        cc = 0;

        stq(a2, env->regs[r3]);

    } else {

        cc = 1;

        env->regs[r1] = v2;

    }

    return cc;

}

/* compare double and swap 64-bit */

uint32_t HELPER(cdsg)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    /* FIXME: locking? */

    uint32_t cc;

    uint64_t v2_hi = ldq(a2);

    uint64_t v2_lo = ldq(a2 + 8);

    uint64_t v1_hi = env->regs[r1];

    uint64_t v1_lo = env->regs[r1 + 1];

    if ((v1_hi == v2_hi) && (v1_lo == v2_lo)) {

        cc = 0;

        stq(a2, env->regs[r3]);

        stq(a2 + 8, env->regs[r3 + 1]);

    } else {

        cc = 1;

        env->regs[r1] = v2_hi;

        env->regs[r1 + 1] = v2_lo;

    }

    return cc;

}

/* compare and swap 32-bit */

uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    /* FIXME: locking? */

    uint32_t cc;

    HELPER_LOG("%s: r1 %d a2 0x%lx r3 %d\n", __FUNCTION__, r1, a2, r3);

    uint32_t v2 = ldl(a2);

    if (((uint32_t)env->regs[r1]) == v2) {

        cc = 0;

        stl(a2, (uint32_t)env->regs[r3]);

    } else {

        cc = 1;

        env->regs[r1] = (env->regs[r1] & 0xffffffff00000000ULL) | v2;

    }

    return cc;

}

static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)

{

    int pos = 24; /* top of the lower half of r1 */

    uint64_t rmask = 0xff000000ULL;

    uint8_t val = 0;

    int ccd = 0;

    uint32_t cc = 0;

    while (mask) {

        if (mask & 8) {

            env->regs[r1] &= ~rmask;

            val = ldub(address);

            if ((val & 0x80) && !ccd) {

                cc = 1;

            }

            ccd = 1;

            if (val && cc == 0) {

                cc = 2;

            }

            env->regs[r1] |= (uint64_t)val << pos;

            address++;

        }

        mask = (mask << 1) & 0xf;

        pos -= 8;

        rmask >>= 8;

    }

    return cc;

}

/* execute instruction

   this instruction executes an insn modified with the contents of r1

   it does not change the executed instruction in memory

   it does not change the program counter

   in other words: tricky...

   currently implemented by interpreting the cases it is most commonly used in

 */

uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

{

    uint16_t insn = lduw_code(addr);

    HELPER_LOG("%s: v1 0x%lx addr 0x%lx insn 0x%x\n", __FUNCTION__, v1, addr,

             insn);

    if ((insn & 0xf0ff) == 0xd000) {

        uint32_t l, insn2, b1, b2, d1, d2;

        l = v1 & 0xff;

        insn2 = ldl_code(addr + 2);

        b1 = (insn2 >> 28) & 0xf;

        b2 = (insn2 >> 12) & 0xf;

        d1 = (insn2 >> 16) & 0xfff;

        d2 = insn2 & 0xfff;

        switch (insn & 0xf00) {

        case 0x200:

            helper_mvc(l, get_address(0, b1, d1), get_address(0, b2, d2));

            break;

        case 0x500:

            cc = helper_clc(l, get_address(0, b1, d1), get_address(0, b2, d2));

            break;

        case 0x700:

            cc = helper_xc(l, get_address(0, b1, d1), get_address(0, b2, d2));

            break;

        case 0xc00:

            helper_tr(l, get_address(0, b1, d1), get_address(0, b2, d2));

            break;

        default:

            goto abort;

            break;

        }

    } else if ((insn & 0xff00) == 0x0a00) {

        /* supervisor call */

        HELPER_LOG("%s: svc %ld via execute\n", __FUNCTION__, (insn|v1) & 0xff);

        env->psw.addr = ret - 4;

        env->int_svc_code = (insn|v1) & 0xff;

        env->int_svc_ilc = 4;

        helper_exception(EXCP_SVC);

    } else if ((insn & 0xff00) == 0xbf00) {

        uint32_t insn2, r1, r3, b2, d2;

        insn2 = ldl_code(addr + 2);

        r1 = (insn2 >> 20) & 0xf;

        r3 = (insn2 >> 16) & 0xf;

        b2 = (insn2 >> 12) & 0xf;

        d2 = insn2 & 0xfff;

        cc = helper_icm(r1, get_address(0, b2, d2), r3);

    } else {

abort:

        cpu_abort(env, "EXECUTE on instruction prefix 0x%x not implemented\n",

                  insn);

    }

    return cc;

}

/* absolute value 32-bit */

uint32_t HELPER(abs_i32)(int32_t val)

{

    if (val < 0) {

        return -val;

    } else {

        return val;

    }

}

/* negative absolute value 32-bit */

int32_t HELPER(nabs_i32)(int32_t val)

{

    if (val < 0) {

        return val;

    } else {

        return -val;

    }

}

/* absolute value 64-bit */

uint64_t HELPER(abs_i64)(int64_t val)

{

    HELPER_LOG("%s: val 0x%" PRIx64 "\n", __FUNCTION__, val);

    if (val < 0) {

        return -val;

    } else {

        return val;

    }

}

/* negative absolute value 64-bit */

int64_t HELPER(nabs_i64)(int64_t val)

{

    if (val < 0) {

        return val;

    } else {

        return -val;

    }

}

/* add with carry 32-bit unsigned */

uint32_t HELPER(addc_u32)(uint32_t cc, uint32_t v1, uint32_t v2)

{

    uint32_t res;

    res = v1 + v2;

    if (cc & 2) {

        res++;

    }

    return res;

}

/* store character under mask high operates on the upper half of r1 */

void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)

{

    int pos = 56; /* top of the upper half of r1 */

    while (mask) {

        if (mask & 8) {

            stb(address, (env->regs[r1] >> pos) & 0xff);

            address++;

        }

        mask = (mask << 1) & 0xf;

        pos -= 8;

    }

}

/* insert character under mask high; same as icm, but operates on the

   upper half of r1 */

uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)

{

    int pos = 56; /* top of the upper half of r1 */

    uint64_t rmask = 0xff00000000000000ULL;

    uint8_t val = 0;

    int ccd = 0;

    uint32_t cc = 0;

    while (mask) {

        if (mask & 8) {

            env->regs[r1] &= ~rmask;

            val = ldub(address);

            if ((val & 0x80) && !ccd) {

                cc = 1;

            }

            ccd = 1;

            if (val && cc == 0) {

                cc = 2;

            }

            env->regs[r1] |= (uint64_t)val << pos;

            address++;

        }

        mask = (mask << 1) & 0xf;

        pos -= 8;

        rmask >>= 8;

    }

    return cc;

}

/* insert psw mask and condition code into r1 */

void HELPER(ipm)(uint32_t cc, uint32_t r1)

{

    uint64_t r = env->regs[r1];

    r &= 0xffffffff00ffffffULL;

    r |= (cc << 28) | ( (env->psw.mask >> 40) & 0xf );

    env->regs[r1] = r;

    HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __FUNCTION__,

               cc, env->psw.mask, r);

}

/* load access registers r1 to r3 from memory at a2 */

void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    int i;

    for (i = r1;; i = (i + 1) % 16) {

        env->aregs[i] = ldl(a2);

        a2 += 4;

        if (i == r3) {

            break;

        }

    }

}

/* store access registers r1 to r3 in memory at a2 */

void HELPER(stam)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    int i;

    for (i = r1;; i = (i + 1) % 16) {

        stl(a2, env->aregs[i]);

        a2 += 4;

        if (i == r3) {

            break;

        }

    }

}

/* move long */

uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)

{

    uint64_t destlen = env->regs[r1 + 1] & 0xffffff;

    uint64_t dest = get_address_31fix(r1);

    uint64_t srclen = env->regs[r2 + 1] & 0xffffff;

    uint64_t src = get_address_31fix(r2);

    uint8_t pad = src >> 24;

    uint8_t v;

    uint32_t cc;

    if (destlen == srclen) {

        cc = 0;

    } else if (destlen < srclen) {

        cc = 1;

    } else {

        cc = 2;

    }

    if (srclen > destlen) {

        srclen = destlen;

    }

    for (; destlen && srclen; src++, dest++, destlen--, srclen--) {

        v = ldub(src);

        stb(dest, v);

    }

    for (; destlen; dest++, destlen--) {

        stb(dest, pad);

    }

    env->regs[r1 + 1] = destlen;

    /* can't use srclen here, we trunc'ed it */

    env->regs[r2 + 1] -= src - env->regs[r2];

    env->regs[r1] = dest;

    env->regs[r2] = src;

    return cc;

}

/* move long extended another memcopy insn with more bells and whistles */

uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)

{

    uint64_t destlen = env->regs[r1 + 1];

    uint64_t dest = env->regs[r1];

    uint64_t srclen = env->regs[r3 + 1];

    uint64_t src = env->regs[r3];

    uint8_t pad = a2 & 0xff;

    uint8_t v;

    uint32_t cc;

    if (!(env->psw.mask & PSW_MASK_64)) {

        destlen = (uint32_t)destlen;

        srclen = (uint32_t)srclen;

        dest &= 0x7fffffff;

        src &= 0x7fffffff;

    }

    if (destlen == srclen) {

        cc = 0;

    } else if (destlen < srclen) {

        cc = 1;

    } else {

        cc = 2;

    }

    if (srclen > destlen) {

        srclen = destlen;

    }

    for (; destlen && srclen; src++, dest++, destlen--, srclen--) {

        v = ldub(src);

        stb(dest, v);

    }

    for (; destlen; dest++, destlen--) {

        stb(dest, pad);

    }

    env->regs[r1 + 1] = destlen;

    /* can't use srclen here, we trunc'ed it */

    /* FIXME: 31-bit mode! */

    env->regs[r3 + 1] -= src - env->regs[r3];

    env->regs[r1] = dest;

    env->regs[r3] = src;