[qemu.git] / target-s390x / cc_helper.c

/*
 *  S/390 condition code 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 "helper.h"
#include "qemu/host-utils.h"

/* #define DEBUG_HELPER */
#ifdef DEBUG_HELPER
#define HELPER_LOG(x...) qemu_log(x)
#else
#define HELPER_LOG(x...)
#endif

static uint32_t cc_calc_ltgt_32(int32_t src, int32_t dst)
{
    if (src == dst) {
        return 0;
    } else if (src < dst) {
        return 1;
    } else {
        return 2;
    }
}

static uint32_t cc_calc_ltgt0_32(int32_t dst)
{
    return cc_calc_ltgt_32(dst, 0);
}

static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
{
    if (src == dst) {
        return 0;
    } else if (src < dst) {
        return 1;
    } else {
        return 2;
    }
}

static uint32_t cc_calc_ltgt0_64(int64_t dst)
{
    return cc_calc_ltgt_64(dst, 0);
}

static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
{
    if (src == dst) {
        return 0;
    } else if (src < dst) {
        return 1;
    } else {
        return 2;
    }
}

static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
{
    if (src == dst) {
        return 0;
    } else if (src < dst) {
        return 1;
    } else {
        return 2;
    }
}

static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
{
    uint32_t r = val & mask;

    if (r == 0) {
        return 0;
    } else if (r == mask) {
        return 3;
    } else {
        return 1;
    }
}

static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
{
    uint64_t r = val & mask;

    if (r == 0) {
        return 0;
    } else if (r == mask) {
        return 3;
    } else {
        int top = clz64(mask);
        if ((int64_t)(val << top) < 0) {
            return 2;
        } else {
            return 1;
        }
    }
}

static uint32_t cc_calc_nz(uint64_t dst)
{
    return !!dst;
}

static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
{
    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
        return 3; /* overflow */
    } else {
        if (ar < 0) {
            return 1;
        } else if (ar > 0) {
            return 2;
        } else {
            return 0;
        }
    }
}

static uint32_t cc_calc_addu_64(uint64_t a1, uint64_t a2, uint64_t ar)
{
    return (ar != 0) + 2 * (ar < a1);
}

static uint32_t cc_calc_addc_64(uint64_t a1, uint64_t a2, uint64_t ar)
{
    /* Recover a2 + carry_in.  */
    uint64_t a2c = ar - a1;
    /* Check for a2+carry_in overflow, then a1+a2c overflow.  */
    int carry_out = (a2c < a2) || (ar < a1);

    return (ar != 0) + 2 * carry_out;
}

static uint32_t cc_calc_sub_64(int64_t a1, int64_t a2, int64_t ar)
{
    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
        return 3; /* overflow */
    } else {
        if (ar < 0) {
            return 1;
        } else if (ar > 0) {
            return 2;
        } else {
            return 0;
        }
    }
}

static uint32_t cc_calc_subu_64(uint64_t a1, uint64_t a2, uint64_t ar)
{
    if (ar == 0) {
        return 2;
    } else {
        if (a2 > a1) {
            return 1;
        } else {
            return 3;
        }
    }
}

static uint32_t cc_calc_subb_64(uint64_t a1, uint64_t a2, uint64_t ar)
{
    /* We had borrow-in if normal subtraction isn't equal.  */
    int borrow_in = ar - (a1 - a2);
    int borrow_out;

    /* If a2 was ULONG_MAX, and borrow_in, then a2 is logically 65 bits,
       and we must have had borrow out.  */
    if (borrow_in && a2 == (uint64_t)-1) {
        borrow_out = 1;
    } else {
        a2 += borrow_in;
        borrow_out = (a2 > a1);
    }

    return (ar != 0) + 2 * !borrow_out;
}

static uint32_t cc_calc_abs_64(int64_t dst)
{
    if ((uint64_t)dst == 0x8000000000000000ULL) {
        return 3;
    } else if (dst) {
        return 1;
    } else {
        return 0;
    }
}

static uint32_t cc_calc_nabs_64(int64_t dst)
{
    return !!dst;
}

static uint32_t cc_calc_comp_64(int64_t dst)
{
    if ((uint64_t)dst == 0x8000000000000000ULL) {
        return 3;
    } else if (dst < 0) {
        return 1;
    } else if (dst > 0) {
        return 2;
    } else {
        return 0;
    }
}


static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
{
    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
        return 3; /* overflow */
    } else {
        if (ar < 0) {
            return 1;
        } else if (ar > 0) {
            return 2;
        } else {
            return 0;
        }
    }
}

static uint32_t cc_calc_addu_32(uint32_t a1, uint32_t a2, uint32_t ar)
{
    return (ar != 0) + 2 * (ar < a1);
}

static uint32_t cc_calc_addc_32(uint32_t a1, uint32_t a2, uint32_t ar)
{
    /* Recover a2 + carry_in.  */
    uint32_t a2c = ar - a1;
    /* Check for a2+carry_in overflow, then a1+a2c overflow.  */
    int carry_out = (a2c < a2) || (ar < a1);

    return (ar != 0) + 2 * carry_out;
}

static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
{
    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
        return 3; /* overflow */
    } else {
        if (ar < 0) {
            return 1;
        } else if (ar > 0) {
            return 2;
        } else {
            return 0;
        }
    }
}

static uint32_t cc_calc_subu_32(uint32_t a1, uint32_t a2, uint32_t ar)
{
    if (ar == 0) {
        return 2;
    } else {
        if (a2 > a1) {
            return 1;
        } else {
            return 3;
        }
    }
}

static uint32_t cc_calc_subb_32(uint32_t a1, uint32_t a2, uint32_t ar)
{
    /* We had borrow-in if normal subtraction isn't equal.  */
    int borrow_in = ar - (a1 - a2);
    int borrow_out;

    /* If a2 was UINT_MAX, and borrow_in, then a2 is logically 65 bits,
       and we must have had borrow out.  */
    if (borrow_in && a2 == (uint32_t)-1) {
        borrow_out = 1;
    } else {
        a2 += borrow_in;
        borrow_out = (a2 > a1);
    }

    return (ar != 0) + 2 * !borrow_out;
}

static uint32_t cc_calc_abs_32(int32_t dst)
{
    if ((uint32_t)dst == 0x80000000UL) {
        return 3;
    } else if (dst) {
        return 1;
    } else {
        return 0;
    }
}

static uint32_t cc_calc_nabs_32(int32_t dst)
{
    return !!dst;
}

static uint32_t cc_calc_comp_32(int32_t dst)
{
    if ((uint32_t)dst == 0x80000000UL) {
        return 3;
    } else if (dst < 0) {
        return 1;
    } else if (dst > 0) {
        return 2;
    } else {
        return 0;
    }
}

/* calculate condition code for insert character under mask insn */
static uint32_t cc_calc_icm(uint64_t mask, uint64_t val)
{
    if ((val & mask) == 0) {
        return 0;
    } else {
        int top = clz64(mask);
        if ((int64_t)(val << top) < 0) {
            return 1;
        } else {
            return 2;
        }
    }
}

static uint32_t cc_calc_sla_32(uint32_t src, int shift)
{
    uint32_t mask = ((1U << shift) - 1U) << (32 - shift);
    uint32_t sign = 1U << 31;
    uint32_t match;
    int32_t r;

    /* Check if the sign bit stays the same.  */
    if (src & sign) {
        match = mask;
    } else {
        match = 0;
    }
    if ((src & mask) != match) {
        /* Overflow.  */
        return 3;
    }

    r = ((src << shift) & ~sign) | (src & sign);
    if (r == 0) {
        return 0;
    } else if (r < 0) {
        return 1;
    }
    return 2;
}

static uint32_t cc_calc_sla_64(uint64_t src, int shift)
{
    uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
    uint64_t sign = 1ULL << 63;
    uint64_t match;
    int64_t r;

    /* Check if the sign bit stays the same.  */
    if (src & sign) {
        match = mask;
    } else {
        match = 0;
    }
    if ((src & mask) != match) {
        /* Overflow.  */
        return 3;
    }

    r = ((src << shift) & ~sign) | (src & sign);
    if (r == 0) {
        return 0;
    } else if (r < 0) {
        return 1;
    }
    return 2;
}

static uint32_t cc_calc_flogr(uint64_t dst)
{
    return dst ? 2 : 0;
}

static uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
                                  uint64_t src, uint64_t dst, uint64_t vr)
{
    uint32_t r = 0;

    switch (cc_op) {
    case CC_OP_CONST0:
    case CC_OP_CONST1:
    case CC_OP_CONST2:
    case CC_OP_CONST3:
        /* cc_op value _is_ cc */
        r = cc_op;
        break;
    case CC_OP_LTGT0_32:
        r = cc_calc_ltgt0_32(dst);
        break;
    case CC_OP_LTGT0_64:
        r =  cc_calc_ltgt0_64(dst);
        break;
    case CC_OP_LTGT_32:
        r =  cc_calc_ltgt_32(src, dst);
        break;
    case CC_OP_LTGT_64:
        r =  cc_calc_ltgt_64(src, dst);
        break;
    case CC_OP_LTUGTU_32:
        r =  cc_calc_ltugtu_32(src, dst);
        break;
    case CC_OP_LTUGTU_64:
        r =  cc_calc_ltugtu_64(src, dst);
        break;
    case CC_OP_TM_32:
        r =  cc_calc_tm_32(src, dst);
        break;
    case CC_OP_TM_64:
        r =  cc_calc_tm_64(src, dst);
        break;
    case CC_OP_NZ:
        r =  cc_calc_nz(dst);
        break;
    case CC_OP_ADD_64:
        r =  cc_calc_add_64(src, dst, vr);
        break;
    case CC_OP_ADDU_64:
        r =  cc_calc_addu_64(src, dst, vr);
        break;
    case CC_OP_ADDC_64:
        r =  cc_calc_addc_64(src, dst, vr);
        break;
    case CC_OP_SUB_64:
        r =  cc_calc_sub_64(src, dst, vr);
        break;
    case CC_OP_SUBU_64:
        r =  cc_calc_subu_64(src, dst, vr);
        break;
    case CC_OP_SUBB_64:
        r =  cc_calc_subb_64(src, dst, vr);
        break;
    case CC_OP_ABS_64:
        r =  cc_calc_abs_64(dst);
        break;
    case CC_OP_NABS_64:
        r =  cc_calc_nabs_64(dst);
        break;
    case CC_OP_COMP_64:
        r =  cc_calc_comp_64(dst);
        break;

    case CC_OP_ADD_32:
        r =  cc_calc_add_32(src, dst, vr);
        break;
    case CC_OP_ADDU_32:
        r =  cc_calc_addu_32(src, dst, vr);
        break;
    case CC_OP_ADDC_32:
        r =  cc_calc_addc_32(src, dst, vr);
        break;
    case CC_OP_SUB_32:
        r =  cc_calc_sub_32(src, dst, vr);
        break;
    case CC_OP_SUBU_32:
        r =  cc_calc_subu_32(src, dst, vr);
        break;
    case CC_OP_SUBB_32:
        r =  cc_calc_subb_32(src, dst, vr);
        break;
    case CC_OP_ABS_32:
        r =  cc_calc_abs_32(dst);
        break;
    case CC_OP_NABS_32:
        r =  cc_calc_nabs_32(dst);
        break;
    case CC_OP_COMP_32:
        r =  cc_calc_comp_32(dst);
        break;

    case CC_OP_ICM:
        r =  cc_calc_icm(src, dst);
        break;
    case CC_OP_SLA_32:
        r =  cc_calc_sla_32(src, dst);
        break;
    case CC_OP_SLA_64:
        r =  cc_calc_sla_64(src, dst);
        break;
    case CC_OP_FLOGR:
        r = cc_calc_flogr(dst);
        break;

    case CC_OP_NZ_F32:
        r = set_cc_nz_f32(dst);
        break;
    case CC_OP_NZ_F64:
        r = set_cc_nz_f64(dst);
        break;
    case CC_OP_NZ_F128:
        r = set_cc_nz_f128(make_float128(src, dst));
        break;

    default:
        cpu_abort(env, "Unknown CC operation: %s\n", cc_name(cc_op));
    }

    HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
               cc_name(cc_op), src, dst, vr, r);
    return r;
}

uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
                 uint64_t vr)
{
    return do_calc_cc(env, cc_op, src, dst, vr);
}

uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
                         uint64_t dst, uint64_t vr)
{
    return do_calc_cc(env, cc_op, src, dst, vr);
}

#ifndef CONFIG_USER_ONLY
void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
{
    load_psw(env, mask, addr);
    cpu_loop_exit(env);
}

void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
{
    HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);

    switch (a1 & 0xf00) {
    case 0x000:
        env->psw.mask &= ~PSW_MASK_ASC;
        env->psw.mask |= PSW_ASC_PRIMARY;
        break;
    case 0x100:
        env->psw.mask &= ~PSW_MASK_ASC;
        env->psw.mask |= PSW_ASC_SECONDARY;
        break;
    case 0x300:
        env->psw.mask &= ~PSW_MASK_ASC;
        env->psw.mask |= PSW_ASC_HOME;
        break;
    default:
        qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
        program_interrupt(env, PGM_SPECIFICATION, 2);
        break;
    }
}
#endif
Commit	Line	Data
a78b0504 BS	1	/*
	2	* S/390 condition code helper routines
	3	*
	4	* Copyright (c) 2009 Ulrich Hecht
	5	* Copyright (c) 2009 Alexander Graf
	6	*
	7	* This library is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2 of the License, or (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include "cpu.h"
a78b0504	22	#include "helper.h"
00d2dc19	23	#include "qemu/host-utils.h"
a78b0504 BS	24
	25	/* #define DEBUG_HELPER */
	26	#ifdef DEBUG_HELPER
	27	#define HELPER_LOG(x...) qemu_log(x)
	28	#else
	29	#define HELPER_LOG(x...)
	30	#endif
	31
443aaeb8	32	static uint32_t cc_calc_ltgt_32(int32_t src, int32_t dst)
a78b0504 BS	33	{
	34	if (src == dst) {
	35	return 0;
	36	} else if (src < dst) {
	37	return 1;
	38	} else {
	39	return 2;
	40	}
	41	}
	42
443aaeb8	43	static uint32_t cc_calc_ltgt0_32(int32_t dst)
a78b0504	44	{
443aaeb8	45	return cc_calc_ltgt_32(dst, 0);
a78b0504 BS	46	}
a78b0504 BS	47
443aaeb8	48	static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
a78b0504 BS	49	{
	50	if (src == dst) {
	51	return 0;
	52	} else if (src < dst) {
	53	return 1;
	54	} else {
	55	return 2;
	56	}
	57	}
	58
443aaeb8	59	static uint32_t cc_calc_ltgt0_64(int64_t dst)
a78b0504	60	{
443aaeb8	61	return cc_calc_ltgt_64(dst, 0);
a78b0504 BS	62	}
a78b0504 BS	63
443aaeb8	64	static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
a78b0504 BS	65	{
	66	if (src == dst) {
	67	return 0;
	68	} else if (src < dst) {
	69	return 1;
	70	} else {
	71	return 2;
	72	}
	73	}
	74
443aaeb8	75	static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
a78b0504 BS	76	{
	77	if (src == dst) {
	78	return 0;
	79	} else if (src < dst) {
	80	return 1;
	81	} else {
	82	return 2;
	83	}
	84	}
	85
443aaeb8	86	static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
a78b0504	87	{
00d2dc19	88	uint32_t r = val & mask;
a78b0504	89
00d2dc19	90	if (r == 0) {
a78b0504 BS	91	return 0;
	92	} else if (r == mask) {
	93	return 3;
	94	} else {
	95	return 1;
	96	}
	97	}
	98
443aaeb8	99	static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
a78b0504	100	{
00d2dc19	101	uint64_t r = val & mask;
a78b0504	102
00d2dc19	103	if (r == 0) {
a78b0504 BS	104	return 0;
	105	} else if (r == mask) {
	106	return 3;
	107	} else {
00d2dc19 RH	108	int top = clz64(mask);
00d2dc19 RH	109	if ((int64_t)(val << top) < 0) {
a78b0504 BS	110	return 2;
	111	} else {
	112	return 1;
	113	}
	114	}
	115	}
	116
443aaeb8	117	static uint32_t cc_calc_nz(uint64_t dst)
a78b0504 BS	118	{
	119	return !!dst;
	120	}
	121
443aaeb8	122	static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
a78b0504 BS	123	{
	124	if ((a1 > 0 && a2 > 0 && ar < 0) \|\| (a1 < 0 && a2 < 0 && ar > 0)) {
	125	return 3; /* overflow */
	126	} else {
	127	if (ar < 0) {
	128	return 1;
	129	} else if (ar > 0) {
	130	return 2;
	131	} else {
	132	return 0;
	133	}
	134	}
	135	}
	136
443aaeb8	137	static uint32_t cc_calc_addu_64(uint64_t a1, uint64_t a2, uint64_t ar)
a78b0504	138	{
4e4bb438 RH	139	return (ar != 0) + 2 * (ar < a1);
	140	}
	141
443aaeb8	142	static uint32_t cc_calc_addc_64(uint64_t a1, uint64_t a2, uint64_t ar)
4e4bb438 RH	143	{
	144	/* Recover a2 + carry_in. */
	145	uint64_t a2c = ar - a1;
	146	/* Check for a2+carry_in overflow, then a1+a2c overflow. */
	147	int carry_out = (a2c < a2) \|\| (ar < a1);
	148
	149	return (ar != 0) + 2 * carry_out;
a78b0504 BS	150	}
a78b0504 BS	151
443aaeb8	152	static uint32_t cc_calc_sub_64(int64_t a1, int64_t a2, int64_t ar)
a78b0504 BS	153	{
	154	if ((a1 > 0 && a2 < 0 && ar < 0) \|\| (a1 < 0 && a2 > 0 && ar > 0)) {
	155	return 3; /* overflow */
	156	} else {
	157	if (ar < 0) {
	158	return 1;
	159	} else if (ar > 0) {
	160	return 2;
	161	} else {
	162	return 0;
	163	}
	164	}
	165	}
	166
443aaeb8	167	static uint32_t cc_calc_subu_64(uint64_t a1, uint64_t a2, uint64_t ar)
a78b0504 BS	168	{
	169	if (ar == 0) {
	170	return 2;
	171	} else {
	172	if (a2 > a1) {
	173	return 1;
	174	} else {
	175	return 3;
	176	}
	177	}
	178	}
	179
443aaeb8	180	static uint32_t cc_calc_subb_64(uint64_t a1, uint64_t a2, uint64_t ar)
4e4bb438 RH	181	{
	182	/* We had borrow-in if normal subtraction isn't equal. */
	183	int borrow_in = ar - (a1 - a2);
	184	int borrow_out;
	185
	186	/* If a2 was ULONG_MAX, and borrow_in, then a2 is logically 65 bits,
	187	and we must have had borrow out. */
	188	if (borrow_in && a2 == (uint64_t)-1) {
	189	borrow_out = 1;
	190	} else {
	191	a2 += borrow_in;
	192	borrow_out = (a2 > a1);
	193	}
	194
	195	return (ar != 0) + 2 * !borrow_out;
	196	}
	197
443aaeb8	198	static uint32_t cc_calc_abs_64(int64_t dst)
a78b0504 BS	199	{
	200	if ((uint64_t)dst == 0x8000000000000000ULL) {
	201	return 3;
	202	} else if (dst) {
	203	return 1;
	204	} else {
	205	return 0;
	206	}
	207	}
	208
443aaeb8	209	static uint32_t cc_calc_nabs_64(int64_t dst)
a78b0504 BS	210	{
	211	return !!dst;
	212	}
	213
443aaeb8	214	static uint32_t cc_calc_comp_64(int64_t dst)
a78b0504 BS	215	{
	216	if ((uint64_t)dst == 0x8000000000000000ULL) {
	217	return 3;
	218	} else if (dst < 0) {
	219	return 1;
	220	} else if (dst > 0) {
	221	return 2;
	222	} else {
	223	return 0;
	224	}
	225	}
	226
	227
443aaeb8	228	static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
a78b0504 BS	229	{
	230	if ((a1 > 0 && a2 > 0 && ar < 0) \|\| (a1 < 0 && a2 < 0 && ar > 0)) {
	231	return 3; /* overflow */
	232	} else {
	233	if (ar < 0) {
	234	return 1;
	235	} else if (ar > 0) {
	236	return 2;
	237	} else {
	238	return 0;
	239	}
	240	}
	241	}
	242
443aaeb8	243	static uint32_t cc_calc_addu_32(uint32_t a1, uint32_t a2, uint32_t ar)
a78b0504	244	{
4e4bb438 RH	245	return (ar != 0) + 2 * (ar < a1);
	246	}
	247
443aaeb8	248	static uint32_t cc_calc_addc_32(uint32_t a1, uint32_t a2, uint32_t ar)
4e4bb438 RH	249	{
	250	/* Recover a2 + carry_in. */
	251	uint32_t a2c = ar - a1;
	252	/* Check for a2+carry_in overflow, then a1+a2c overflow. */
	253	int carry_out = (a2c < a2) \|\| (ar < a1);
	254
	255	return (ar != 0) + 2 * carry_out;
a78b0504 BS	256	}
a78b0504 BS	257
443aaeb8	258	static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
a78b0504 BS	259	{
	260	if ((a1 > 0 && a2 < 0 && ar < 0) \|\| (a1 < 0 && a2 > 0 && ar > 0)) {
	261	return 3; /* overflow */
	262	} else {
	263	if (ar < 0) {
	264	return 1;
	265	} else if (ar > 0) {
	266	return 2;
	267	} else {
	268	return 0;
	269	}
	270	}
	271	}
	272
443aaeb8	273	static uint32_t cc_calc_subu_32(uint32_t a1, uint32_t a2, uint32_t ar)
a78b0504 BS	274	{
	275	if (ar == 0) {
	276	return 2;
	277	} else {
	278	if (a2 > a1) {
	279	return 1;
	280	} else {
	281	return 3;
	282	}
	283	}
	284	}
	285
443aaeb8	286	static uint32_t cc_calc_subb_32(uint32_t a1, uint32_t a2, uint32_t ar)
4e4bb438 RH	287	{
	288	/* We had borrow-in if normal subtraction isn't equal. */
	289	int borrow_in = ar - (a1 - a2);
	290	int borrow_out;
	291
	292	/* If a2 was UINT_MAX, and borrow_in, then a2 is logically 65 bits,
	293	and we must have had borrow out. */
	294	if (borrow_in && a2 == (uint32_t)-1) {
	295	borrow_out = 1;
	296	} else {
	297	a2 += borrow_in;
	298	borrow_out = (a2 > a1);
	299	}
	300
	301	return (ar != 0) + 2 * !borrow_out;
	302	}
	303
443aaeb8	304	static uint32_t cc_calc_abs_32(int32_t dst)
a78b0504 BS	305	{
	306	if ((uint32_t)dst == 0x80000000UL) {
	307	return 3;
	308	} else if (dst) {
	309	return 1;
	310	} else {
	311	return 0;
	312	}
	313	}
	314
443aaeb8	315	static uint32_t cc_calc_nabs_32(int32_t dst)
a78b0504 BS	316	{
	317	return !!dst;
	318	}
	319
443aaeb8	320	static uint32_t cc_calc_comp_32(int32_t dst)
a78b0504 BS	321	{
	322	if ((uint32_t)dst == 0x80000000UL) {
	323	return 3;
	324	} else if (dst < 0) {
	325	return 1;
	326	} else if (dst > 0) {
	327	return 2;
	328	} else {
	329	return 0;
	330	}
	331	}
	332
	333	/* calculate condition code for insert character under mask insn */
58a9e35b	334	static uint32_t cc_calc_icm(uint64_t mask, uint64_t val)
a78b0504	335	{
58a9e35b RH	336	if ((val & mask) == 0) {
	337	return 0;
	338	} else {
	339	int top = clz64(mask);
	340	if ((int64_t)(val << top) < 0) {
a78b0504 BS	341	return 1;
	342	} else {
	343	return 2;
	344	}
	345	}
a78b0504 BS	346	}
a78b0504 BS	347
cbe24bfa	348	static uint32_t cc_calc_sla_32(uint32_t src, int shift)
a78b0504	349	{
cbe24bfa RH	350	uint32_t mask = ((1U << shift) - 1U) << (32 - shift);
	351	uint32_t sign = 1U << 31;
	352	uint32_t match;
	353	int32_t r;
a78b0504	354
cbe24bfa RH	355	/* Check if the sign bit stays the same. */
cbe24bfa RH	356	if (src & sign) {
a78b0504 BS	357	match = mask;
	358	} else {
	359	match = 0;
	360	}
a78b0504	361	if ((src & mask) != match) {
cbe24bfa	362	/* Overflow. */
a78b0504 BS	363	return 3;
	364	}
	365
cbe24bfa RH	366	r = ((src << shift) & ~sign) \| (src & sign);
cbe24bfa RH	367	if (r == 0) {
a78b0504	368	return 0;
cbe24bfa	369	} else if (r < 0) {
a78b0504 BS	370	return 1;
a78b0504 BS	371	}
a78b0504 BS	372	return 2;
	373	}
	374
cbe24bfa RH	375	static uint32_t cc_calc_sla_64(uint64_t src, int shift)
	376	{
	377	uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
	378	uint64_t sign = 1ULL << 63;
	379	uint64_t match;
	380	int64_t r;
	381
	382	/* Check if the sign bit stays the same. */
	383	if (src & sign) {
	384	match = mask;
	385	} else {
	386	match = 0;
	387	}
	388	if ((src & mask) != match) {
	389	/* Overflow. */
	390	return 3;
	391	}
	392
	393	r = ((src << shift) & ~sign) \| (src & sign);
	394	if (r == 0) {
	395	return 0;
	396	} else if (r < 0) {
	397	return 1;
	398	}
	399	return 2;
	400	}
a78b0504	401
102bf2c6 RH	402	static uint32_t cc_calc_flogr(uint64_t dst)
	403	{
	404	return dst ? 2 : 0;
	405	}
	406
443aaeb8	407	static uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
a78b0504 BS	408	uint64_t src, uint64_t dst, uint64_t vr)
	409	{
	410	uint32_t r = 0;
	411
	412	switch (cc_op) {
	413	case CC_OP_CONST0:
	414	case CC_OP_CONST1:
	415	case CC_OP_CONST2:
	416	case CC_OP_CONST3:
	417	/* cc_op value _is_ cc */
	418	r = cc_op;
	419	break;
	420	case CC_OP_LTGT0_32:
443aaeb8	421	r = cc_calc_ltgt0_32(dst);
a78b0504 BS	422	break;
a78b0504 BS	423	case CC_OP_LTGT0_64:
443aaeb8	424	r = cc_calc_ltgt0_64(dst);
a78b0504 BS	425	break;
a78b0504 BS	426	case CC_OP_LTGT_32:
443aaeb8	427	r = cc_calc_ltgt_32(src, dst);
a78b0504 BS	428	break;
a78b0504 BS	429	case CC_OP_LTGT_64:
443aaeb8	430	r = cc_calc_ltgt_64(src, dst);
a78b0504 BS	431	break;
a78b0504 BS	432	case CC_OP_LTUGTU_32:
443aaeb8	433	r = cc_calc_ltugtu_32(src, dst);
a78b0504 BS	434	break;
a78b0504 BS	435	case CC_OP_LTUGTU_64:
443aaeb8	436	r = cc_calc_ltugtu_64(src, dst);
a78b0504 BS	437	break;
a78b0504 BS	438	case CC_OP_TM_32:
443aaeb8	439	r = cc_calc_tm_32(src, dst);
a78b0504 BS	440	break;
a78b0504 BS	441	case CC_OP_TM_64:
443aaeb8	442	r = cc_calc_tm_64(src, dst);
a78b0504 BS	443	break;
a78b0504 BS	444	case CC_OP_NZ:
443aaeb8	445	r = cc_calc_nz(dst);
a78b0504 BS	446	break;
a78b0504 BS	447	case CC_OP_ADD_64:
443aaeb8	448	r = cc_calc_add_64(src, dst, vr);
a78b0504 BS	449	break;
a78b0504 BS	450	case CC_OP_ADDU_64:
443aaeb8	451	r = cc_calc_addu_64(src, dst, vr);
a78b0504	452	break;
4e4bb438	453	case CC_OP_ADDC_64:
443aaeb8	454	r = cc_calc_addc_64(src, dst, vr);
4e4bb438	455	break;
a78b0504	456	case CC_OP_SUB_64:
443aaeb8	457	r = cc_calc_sub_64(src, dst, vr);
a78b0504 BS	458	break;
a78b0504 BS	459	case CC_OP_SUBU_64:
443aaeb8	460	r = cc_calc_subu_64(src, dst, vr);
a78b0504	461	break;
4e4bb438	462	case CC_OP_SUBB_64:
443aaeb8	463	r = cc_calc_subb_64(src, dst, vr);
4e4bb438	464	break;
a78b0504	465	case CC_OP_ABS_64:
443aaeb8	466	r = cc_calc_abs_64(dst);
a78b0504 BS	467	break;
a78b0504 BS	468	case CC_OP_NABS_64:
443aaeb8	469	r = cc_calc_nabs_64(dst);
a78b0504 BS	470	break;
a78b0504 BS	471	case CC_OP_COMP_64:
443aaeb8	472	r = cc_calc_comp_64(dst);
a78b0504 BS	473	break;
	474
	475	case CC_OP_ADD_32:
443aaeb8	476	r = cc_calc_add_32(src, dst, vr);
a78b0504 BS	477	break;
a78b0504 BS	478	case CC_OP_ADDU_32:
443aaeb8	479	r = cc_calc_addu_32(src, dst, vr);
a78b0504	480	break;
4e4bb438	481	case CC_OP_ADDC_32:
443aaeb8	482	r = cc_calc_addc_32(src, dst, vr);
4e4bb438	483	break;
a78b0504	484	case CC_OP_SUB_32:
443aaeb8	485	r = cc_calc_sub_32(src, dst, vr);
a78b0504 BS	486	break;
a78b0504 BS	487	case CC_OP_SUBU_32:
443aaeb8	488	r = cc_calc_subu_32(src, dst, vr);
a78b0504	489	break;
4e4bb438	490	case CC_OP_SUBB_32:
443aaeb8	491	r = cc_calc_subb_32(src, dst, vr);
4e4bb438	492	break;
a78b0504	493	case CC_OP_ABS_32:
443aaeb8	494	r = cc_calc_abs_32(dst);
a78b0504 BS	495	break;
a78b0504 BS	496	case CC_OP_NABS_32:
443aaeb8	497	r = cc_calc_nabs_32(dst);
a78b0504 BS	498	break;
a78b0504 BS	499	case CC_OP_COMP_32:
443aaeb8	500	r = cc_calc_comp_32(dst);
a78b0504 BS	501	break;
	502
	503	case CC_OP_ICM:
58a9e35b	504	r = cc_calc_icm(src, dst);
a78b0504	505	break;
cbe24bfa RH	506	case CC_OP_SLA_32:
	507	r = cc_calc_sla_32(src, dst);
	508	break;
	509	case CC_OP_SLA_64:
	510	r = cc_calc_sla_64(src, dst);
a78b0504	511	break;
102bf2c6 RH	512	case CC_OP_FLOGR:
	513	r = cc_calc_flogr(dst);
	514	break;
a78b0504	515
a78b0504 BS	516	case CC_OP_NZ_F32:
	517	r = set_cc_nz_f32(dst);
	518	break;
	519	case CC_OP_NZ_F64:
	520	r = set_cc_nz_f64(dst);
	521	break;
587626f8 RH	522	case CC_OP_NZ_F128:
	523	r = set_cc_nz_f128(make_float128(src, dst));
	524	break;
a78b0504 BS	525
	526	default:
	527	cpu_abort(env, "Unknown CC operation: %s\n", cc_name(cc_op));
	528	}
	529
	530	HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
	531	cc_name(cc_op), src, dst, vr, r);
	532	return r;
	533	}
	534
	535	uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
	536	uint64_t vr)
	537	{
	538	return do_calc_cc(env, cc_op, src, dst, vr);
	539	}
	540
932385a3 BS	541	uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
932385a3 BS	542	uint64_t dst, uint64_t vr)
a78b0504 BS	543	{
	544	return do_calc_cc(env, cc_op, src, dst, vr);
	545	}
	546
a78b0504	547	#ifndef CONFIG_USER_ONLY
932385a3	548	void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
a78b0504 BS	549	{
	550	load_psw(env, mask, addr);
	551	cpu_loop_exit(env);
	552	}
	553
932385a3	554	void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
a78b0504 BS	555	{
	556	HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
	557
	558	switch (a1 & 0xf00) {
	559	case 0x000:
	560	env->psw.mask &= ~PSW_MASK_ASC;
	561	env->psw.mask \|= PSW_ASC_PRIMARY;
	562	break;
	563	case 0x100:
	564	env->psw.mask &= ~PSW_MASK_ASC;
	565	env->psw.mask \|= PSW_ASC_SECONDARY;
	566	break;
	567	case 0x300:
	568	env->psw.mask &= ~PSW_MASK_ASC;
	569	env->psw.mask \|= PSW_ASC_HOME;
	570	break;
	571	default:
	572	qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
	573	program_interrupt(env, PGM_SPECIFICATION, 2);
	574	break;
	575	}
	576	}
	577	#endif