0007-target-s390x-split-condition-code-helpers.patch

   1 From f642126aece222f6ff87d26c29f00e1b6c47e10a Mon Sep 17 00:00:00 2001
   2 From: Blue Swirl <blauwirbel@gmail.com>
   3 Date: Sun, 2 Sep 2012 07:33:32 +0000
   4 Subject: [PATCH] target-s390x: split condition code helpers
   5
   6 Move condition code helpers to cc_helper.c.
   7
   8 Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
   9 Signed-off-by: Alexander Graf <agraf@suse.de>
  10 Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
  11 ---
  12  target-s390x/Makefile.objs |   3 +-
  13  target-s390x/cc_helper.c   | 551 +++++++++++++++++++++++++++++++++++++++++++++
  14  target-s390x/cpu.h         |   3 +
  15  target-s390x/op_helper.c   | 522 +-----------------------------------------
  16  4 files changed, 557 insertions(+), 522 deletions(-)
  17  create mode 100644 target-s390x/cc_helper.c
  18
  19 diff --git a/target-s390x/Makefile.objs b/target-s390x/Makefile.objs
  20 index 23b3bd9..f9437d6 100644
  21 --- a/target-s390x/Makefile.objs
  22 +++ b/target-s390x/Makefile.objs
  23 @@ -1,7 +1,8 @@
  24  obj-y += translate.o op_helper.o helper.o cpu.o interrupt.o
  25 -obj-y += fpu_helper.o
  26 +obj-y += fpu_helper.o cc_helper.o
  27  obj-$(CONFIG_SOFTMMU) += machine.o
  28  obj-$(CONFIG_KVM) += kvm.o
  29
  30  $(obj)/op_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
  31  $(obj)/fpu_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
  32 +$(obj)/cc_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
  33 diff --git a/target-s390x/cc_helper.c b/target-s390x/cc_helper.c
  34 new file mode 100644
  35 index 0000000..2ac1659
  36 --- /dev/null
  37 +++ b/target-s390x/cc_helper.c
  38 @@ -0,0 +1,551 @@
  39 +/*
  40 + *  S/390 condition code helper routines
  41 + *
  42 + *  Copyright (c) 2009 Ulrich Hecht
  43 + *  Copyright (c) 2009 Alexander Graf
  44 + *
  45 + * This library is free software; you can redistribute it and/or
  46 + * modify it under the terms of the GNU Lesser General Public
  47 + * License as published by the Free Software Foundation; either
  48 + * version 2 of the License, or (at your option) any later version.
  49 + *
  50 + * This library is distributed in the hope that it will be useful,
  51 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  52 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  53 + * Lesser General Public License for more details.
  54 + *
  55 + * You should have received a copy of the GNU Lesser General Public
  56 + * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  57 + */
  58 +
  59 +#include "cpu.h"
  60 +#include "dyngen-exec.h"
  61 +#include "helper.h"
  62 +
  63 +/* #define DEBUG_HELPER */
  64 +#ifdef DEBUG_HELPER
  65 +#define HELPER_LOG(x...) qemu_log(x)
  66 +#else
  67 +#define HELPER_LOG(x...)
  68 +#endif
  69 +
  70 +static inline uint32_t cc_calc_ltgt_32(CPUS390XState *env, int32_t src,
  71 +                                       int32_t dst)
  72 +{
  73 +    if (src == dst) {
  74 +        return 0;
  75 +    } else if (src < dst) {
  76 +        return 1;
  77 +    } else {
  78 +        return 2;
  79 +    }
  80 +}
  81 +
  82 +static inline uint32_t cc_calc_ltgt0_32(CPUS390XState *env, int32_t dst)
  83 +{
  84 +    return cc_calc_ltgt_32(env, dst, 0);
  85 +}
  86 +
  87 +static inline uint32_t cc_calc_ltgt_64(CPUS390XState *env, int64_t src,
  88 +                                       int64_t dst)
  89 +{
  90 +    if (src == dst) {
  91 +        return 0;
  92 +    } else if (src < dst) {
  93 +        return 1;
  94 +    } else {
  95 +        return 2;
  96 +    }
  97 +}
  98 +
  99 +static inline uint32_t cc_calc_ltgt0_64(CPUS390XState *env, int64_t dst)
 100 +{
 101 +    return cc_calc_ltgt_64(env, dst, 0);
 102 +}
 103 +
 104 +static inline uint32_t cc_calc_ltugtu_32(CPUS390XState *env, uint32_t src,
 105 +                                         uint32_t dst)
 106 +{
 107 +    if (src == dst) {
 108 +        return 0;
 109 +    } else if (src < dst) {
 110 +        return 1;
 111 +    } else {
 112 +        return 2;
 113 +    }
 114 +}
 115 +
 116 +static inline uint32_t cc_calc_ltugtu_64(CPUS390XState *env, uint64_t src,
 117 +                                         uint64_t dst)
 118 +{
 119 +    if (src == dst) {
 120 +        return 0;
 121 +    } else if (src < dst) {
 122 +        return 1;
 123 +    } else {
 124 +        return 2;
 125 +    }
 126 +}
 127 +
 128 +static inline uint32_t cc_calc_tm_32(CPUS390XState *env, uint32_t val,
 129 +                                     uint32_t mask)
 130 +{
 131 +    uint16_t r = val & mask;
 132 +
 133 +    HELPER_LOG("%s: val 0x%x mask 0x%x\n", __func__, val, mask);
 134 +    if (r == 0 || mask == 0) {
 135 +        return 0;
 136 +    } else if (r == mask) {
 137 +        return 3;
 138 +    } else {
 139 +        return 1;
 140 +    }
 141 +}
 142 +
 143 +/* set condition code for test under mask */
 144 +static inline uint32_t cc_calc_tm_64(CPUS390XState *env, uint64_t val,
 145 +                                     uint32_t mask)
 146 +{
 147 +    uint16_t r = val & mask;
 148 +
 149 +    HELPER_LOG("%s: val 0x%lx mask 0x%x r 0x%x\n", __func__, val, mask, r);
 150 +    if (r == 0 || mask == 0) {
 151 +        return 0;
 152 +    } else if (r == mask) {
 153 +        return 3;
 154 +    } else {
 155 +        while (!(mask & 0x8000)) {
 156 +            mask <<= 1;
 157 +            val <<= 1;
 158 +        }
 159 +        if (val & 0x8000) {
 160 +            return 2;
 161 +        } else {
 162 +            return 1;
 163 +        }
 164 +    }
 165 +}
 166 +
 167 +static inline uint32_t cc_calc_nz(CPUS390XState *env, uint64_t dst)
 168 +{
 169 +    return !!dst;
 170 +}
 171 +
 172 +static inline uint32_t cc_calc_add_64(CPUS390XState *env, int64_t a1,
 173 +                                      int64_t a2, int64_t ar)
 174 +{
 175 +    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 176 +        return 3; /* overflow */
 177 +    } else {
 178 +        if (ar < 0) {
 179 +            return 1;
 180 +        } else if (ar > 0) {
 181 +            return 2;
 182 +        } else {
 183 +            return 0;
 184 +        }
 185 +    }
 186 +}
 187 +
 188 +static inline uint32_t cc_calc_addu_64(CPUS390XState *env, uint64_t a1,
 189 +                                       uint64_t a2, uint64_t ar)
 190 +{
 191 +    if (ar == 0) {
 192 +        if (a1) {
 193 +            return 2;
 194 +        } else {
 195 +            return 0;
 196 +        }
 197 +    } else {
 198 +        if (ar < a1 || ar < a2) {
 199 +            return 3;
 200 +        } else {
 201 +            return 1;
 202 +        }
 203 +    }
 204 +}
 205 +
 206 +static inline uint32_t cc_calc_sub_64(CPUS390XState *env, int64_t a1,
 207 +                                      int64_t a2, int64_t ar)
 208 +{
 209 +    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 210 +        return 3; /* overflow */
 211 +    } else {
 212 +        if (ar < 0) {
 213 +            return 1;
 214 +        } else if (ar > 0) {
 215 +            return 2;
 216 +        } else {
 217 +            return 0;
 218 +        }
 219 +    }
 220 +}
 221 +
 222 +static inline uint32_t cc_calc_subu_64(CPUS390XState *env, uint64_t a1,
 223 +                                       uint64_t a2, uint64_t ar)
 224 +{
 225 +    if (ar == 0) {
 226 +        return 2;
 227 +    } else {
 228 +        if (a2 > a1) {
 229 +            return 1;
 230 +        } else {
 231 +            return 3;
 232 +        }
 233 +    }
 234 +}
 235 +
 236 +static inline uint32_t cc_calc_abs_64(CPUS390XState *env, int64_t dst)
 237 +{
 238 +    if ((uint64_t)dst == 0x8000000000000000ULL) {
 239 +        return 3;
 240 +    } else if (dst) {
 241 +        return 1;
 242 +    } else {
 243 +        return 0;
 244 +    }
 245 +}
 246 +
 247 +static inline uint32_t cc_calc_nabs_64(CPUS390XState *env, int64_t dst)
 248 +{
 249 +    return !!dst;
 250 +}
 251 +
 252 +static inline uint32_t cc_calc_comp_64(CPUS390XState *env, int64_t dst)
 253 +{
 254 +    if ((uint64_t)dst == 0x8000000000000000ULL) {
 255 +        return 3;
 256 +    } else if (dst < 0) {
 257 +        return 1;
 258 +    } else if (dst > 0) {
 259 +        return 2;
 260 +    } else {
 261 +        return 0;
 262 +    }
 263 +}
 264 +
 265 +
 266 +static inline uint32_t cc_calc_add_32(CPUS390XState *env, int32_t a1,
 267 +                                      int32_t a2, int32_t ar)
 268 +{
 269 +    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 270 +        return 3; /* overflow */
 271 +    } else {
 272 +        if (ar < 0) {
 273 +            return 1;
 274 +        } else if (ar > 0) {
 275 +            return 2;
 276 +        } else {
 277 +            return 0;
 278 +        }
 279 +    }
 280 +}
 281 +
 282 +static inline uint32_t cc_calc_addu_32(CPUS390XState *env, uint32_t a1,
 283 +                                       uint32_t a2, uint32_t ar)
 284 +{
 285 +    if (ar == 0) {
 286 +        if (a1) {
 287 +            return 2;
 288 +        } else {
 289 +            return 0;
 290 +        }
 291 +    } else {
 292 +        if (ar < a1 || ar < a2) {
 293 +            return 3;
 294 +        } else {
 295 +            return 1;
 296 +        }
 297 +    }
 298 +}
 299 +
 300 +static inline uint32_t cc_calc_sub_32(CPUS390XState *env, int32_t a1,
 301 +                                      int32_t a2, int32_t ar)
 302 +{
 303 +    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 304 +        return 3; /* overflow */
 305 +    } else {
 306 +        if (ar < 0) {
 307 +            return 1;
 308 +        } else if (ar > 0) {
 309 +            return 2;
 310 +        } else {
 311 +            return 0;
 312 +        }
 313 +    }
 314 +}
 315 +
 316 +static inline uint32_t cc_calc_subu_32(CPUS390XState *env, uint32_t a1,
 317 +                                       uint32_t a2, uint32_t ar)
 318 +{
 319 +    if (ar == 0) {
 320 +        return 2;
 321 +    } else {
 322 +        if (a2 > a1) {
 323 +            return 1;
 324 +        } else {
 325 +            return 3;
 326 +        }
 327 +    }
 328 +}
 329 +
 330 +static inline uint32_t cc_calc_abs_32(CPUS390XState *env, int32_t dst)
 331 +{
 332 +    if ((uint32_t)dst == 0x80000000UL) {
 333 +        return 3;
 334 +    } else if (dst) {
 335 +        return 1;
 336 +    } else {
 337 +        return 0;
 338 +    }
 339 +}
 340 +
 341 +static inline uint32_t cc_calc_nabs_32(CPUS390XState *env, int32_t dst)
 342 +{
 343 +    return !!dst;
 344 +}
 345 +
 346 +static inline uint32_t cc_calc_comp_32(CPUS390XState *env, int32_t dst)
 347 +{
 348 +    if ((uint32_t)dst == 0x80000000UL) {
 349 +        return 3;
 350 +    } else if (dst < 0) {
 351 +        return 1;
 352 +    } else if (dst > 0) {
 353 +        return 2;
 354 +    } else {
 355 +        return 0;
 356 +    }
 357 +}
 358 +
 359 +/* calculate condition code for insert character under mask insn */
 360 +static inline uint32_t cc_calc_icm_32(CPUS390XState *env, uint32_t mask,
 361 +                                      uint32_t val)
 362 +{
 363 +    uint32_t cc;
 364 +
 365 +    HELPER_LOG("%s: mask 0x%x val %d\n", __func__, mask, val);
 366 +    if (mask == 0xf) {
 367 +        if (!val) {
 368 +            return 0;
 369 +        } else if (val & 0x80000000) {
 370 +            return 1;
 371 +        } else {
 372 +            return 2;
 373 +        }
 374 +    }
 375 +
 376 +    if (!val || !mask) {
 377 +        cc = 0;
 378 +    } else {
 379 +        while (mask != 1) {
 380 +            mask >>= 1;
 381 +            val >>= 8;
 382 +        }
 383 +        if (val & 0x80) {
 384 +            cc = 1;
 385 +        } else {
 386 +            cc = 2;
 387 +        }
 388 +    }
 389 +    return cc;
 390 +}
 391 +
 392 +static inline uint32_t cc_calc_slag(CPUS390XState *env, uint64_t src,
 393 +                                    uint64_t shift)
 394 +{
 395 +    uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
 396 +    uint64_t match, r;
 397 +
 398 +    /* check if the sign bit stays the same */
 399 +    if (src & (1ULL << 63)) {
 400 +        match = mask;
 401 +    } else {
 402 +        match = 0;
 403 +    }
 404 +
 405 +    if ((src & mask) != match) {
 406 +        /* overflow */
 407 +        return 3;
 408 +    }
 409 +
 410 +    r = ((src << shift) & ((1ULL << 63) - 1)) | (src & (1ULL << 63));
 411 +
 412 +    if ((int64_t)r == 0) {
 413 +        return 0;
 414 +    } else if ((int64_t)r < 0) {
 415 +        return 1;
 416 +    }
 417 +
 418 +    return 2;
 419 +}
 420 +
 421 +
 422 +static inline uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
 423 +                                  uint64_t src, uint64_t dst, uint64_t vr)
 424 +{
 425 +    uint32_t r = 0;
 426 +
 427 +    switch (cc_op) {
 428 +    case CC_OP_CONST0:
 429 +    case CC_OP_CONST1:
 430 +    case CC_OP_CONST2:
 431 +    case CC_OP_CONST3:
 432 +        /* cc_op value _is_ cc */
 433 +        r = cc_op;
 434 +        break;
 435 +    case CC_OP_LTGT0_32:
 436 +        r = cc_calc_ltgt0_32(env, dst);
 437 +        break;
 438 +    case CC_OP_LTGT0_64:
 439 +        r =  cc_calc_ltgt0_64(env, dst);
 440 +        break;
 441 +    case CC_OP_LTGT_32:
 442 +        r =  cc_calc_ltgt_32(env, src, dst);
 443 +        break;
 444 +    case CC_OP_LTGT_64:
 445 +        r =  cc_calc_ltgt_64(env, src, dst);
 446 +        break;
 447 +    case CC_OP_LTUGTU_32:
 448 +        r =  cc_calc_ltugtu_32(env, src, dst);
 449 +        break;
 450 +    case CC_OP_LTUGTU_64:
 451 +        r =  cc_calc_ltugtu_64(env, src, dst);
 452 +        break;
 453 +    case CC_OP_TM_32:
 454 +        r =  cc_calc_tm_32(env, src, dst);
 455 +        break;
 456 +    case CC_OP_TM_64:
 457 +        r =  cc_calc_tm_64(env, src, dst);
 458 +        break;
 459 +    case CC_OP_NZ:
 460 +        r =  cc_calc_nz(env, dst);
 461 +        break;
 462 +    case CC_OP_ADD_64:
 463 +        r =  cc_calc_add_64(env, src, dst, vr);
 464 +        break;
 465 +    case CC_OP_ADDU_64:
 466 +        r =  cc_calc_addu_64(env, src, dst, vr);
 467 +        break;
 468 +    case CC_OP_SUB_64:
 469 +        r =  cc_calc_sub_64(env, src, dst, vr);
 470 +        break;
 471 +    case CC_OP_SUBU_64:
 472 +        r =  cc_calc_subu_64(env, src, dst, vr);
 473 +        break;
 474 +    case CC_OP_ABS_64:
 475 +        r =  cc_calc_abs_64(env, dst);
 476 +        break;
 477 +    case CC_OP_NABS_64:
 478 +        r =  cc_calc_nabs_64(env, dst);
 479 +        break;
 480 +    case CC_OP_COMP_64:
 481 +        r =  cc_calc_comp_64(env, dst);
 482 +        break;
 483 +
 484 +    case CC_OP_ADD_32:
 485 +        r =  cc_calc_add_32(env, src, dst, vr);
 486 +        break;
 487 +    case CC_OP_ADDU_32:
 488 +        r =  cc_calc_addu_32(env, src, dst, vr);
 489 +        break;
 490 +    case CC_OP_SUB_32:
 491 +        r =  cc_calc_sub_32(env, src, dst, vr);
 492 +        break;
 493 +    case CC_OP_SUBU_32:
 494 +        r =  cc_calc_subu_32(env, src, dst, vr);
 495 +        break;
 496 +    case CC_OP_ABS_32:
 497 +        r =  cc_calc_abs_64(env, dst);
 498 +        break;
 499 +    case CC_OP_NABS_32:
 500 +        r =  cc_calc_nabs_64(env, dst);
 501 +        break;
 502 +    case CC_OP_COMP_32:
 503 +        r =  cc_calc_comp_32(env, dst);
 504 +        break;
 505 +
 506 +    case CC_OP_ICM:
 507 +        r =  cc_calc_icm_32(env, src, dst);
 508 +        break;
 509 +    case CC_OP_SLAG:
 510 +        r =  cc_calc_slag(env, src, dst);
 511 +        break;
 512 +
 513 +    case CC_OP_LTGT_F32:
 514 +        r = set_cc_f32(src, dst);
 515 +        break;
 516 +    case CC_OP_LTGT_F64:
 517 +        r = set_cc_f64(src, dst);
 518 +        break;
 519 +    case CC_OP_NZ_F32:
 520 +        r = set_cc_nz_f32(dst);
 521 +        break;
 522 +    case CC_OP_NZ_F64:
 523 +        r = set_cc_nz_f64(dst);
 524 +        break;
 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 +
 541 +uint32_t HELPER(calc_cc)(uint32_t cc_op, uint64_t src, uint64_t dst,
 542 +                         uint64_t vr)
 543 +{
 544 +    return do_calc_cc(env, cc_op, src, dst, vr);
 545 +}
 546 +
 547 +/* insert psw mask and condition code into r1 */
 548 +void HELPER(ipm)(uint32_t cc, uint32_t r1)
 549 +{
 550 +    uint64_t r = env->regs[r1];
 551 +
 552 +    r &= 0xffffffff00ffffffULL;
 553 +    r |= (cc << 28) | ((env->psw.mask >> 40) & 0xf);
 554 +    env->regs[r1] = r;
 555 +    HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __func__,
 556 +               cc, env->psw.mask, r);
 557 +}
 558 +
 559 +#ifndef CONFIG_USER_ONLY
 560 +void HELPER(load_psw)(uint64_t mask, uint64_t addr)
 561 +{
 562 +    load_psw(env, mask, addr);
 563 +    cpu_loop_exit(env);
 564 +}
 565 +
 566 +void HELPER(sacf)(uint64_t a1)
 567 +{
 568 +    HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
 569 +
 570 +    switch (a1 & 0xf00) {
 571 +    case 0x000:
 572 +        env->psw.mask &= ~PSW_MASK_ASC;
 573 +        env->psw.mask |= PSW_ASC_PRIMARY;
 574 +        break;
 575 +    case 0x100:
 576 +        env->psw.mask &= ~PSW_MASK_ASC;
 577 +        env->psw.mask |= PSW_ASC_SECONDARY;
 578 +        break;
 579 +    case 0x300:
 580 +        env->psw.mask &= ~PSW_MASK_ASC;
 581 +        env->psw.mask |= PSW_ASC_HOME;
 582 +        break;
 583 +    default:
 584 +        qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
 585 +        program_interrupt(env, PGM_SPECIFICATION, 2);
 586 +        break;
 587 +    }
 588 +}
 589 +#endif
 590 diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
 591 index b4620c5..97fde5e 100644
 592 --- a/target-s390x/cpu.h
 593 +++ b/target-s390x/cpu.h
 594 @@ -1005,4 +1005,7 @@ uint32_t set_cc_f64(float64 v1, float64 v2);
 595  uint32_t set_cc_nz_f32(float32 v);
 596  uint32_t set_cc_nz_f64(float64 v);
 597
 598 +/* op_helper.c */
 599 +void program_interrupt(CPUS390XState *env, uint32_t code, int ilc);
 600 +
 601  #endif
 602 diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
 603 index 270bf14..eced890 100644
 604 --- a/target-s390x/op_helper.c
 605 +++ b/target-s390x/op_helper.c
 606 @@ -779,18 +779,6 @@ uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
 607      return cc;
 608  }
 609
 610 -/* insert psw mask and condition code into r1 */
 611 -void HELPER(ipm)(uint32_t cc, uint32_t r1)
 612 -{
 613 -    uint64_t r = env->regs[r1];
 614 -
 615 -    r &= 0xffffffff00ffffffULL;
 616 -    r |= (cc << 28) | ((env->psw.mask >> 40) & 0xf);
 617 -    env->regs[r1] = r;
 618 -    HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __func__,
 619 -               cc, env->psw.mask, r);
 620 -}
 621 -
 622  /* load access registers r1 to r3 from memory at a2 */
 623  void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)
 624  {
 625 @@ -1038,483 +1026,6 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
 626          ((uint32_t)cksm + (cksm >> 32));
 627  }
 628
 629 -static inline uint32_t cc_calc_ltgt_32(CPUS390XState *env, int32_t src,
 630 -                                       int32_t dst)
 631 -{
 632 -    if (src == dst) {
 633 -        return 0;
 634 -    } else if (src < dst) {
 635 -        return 1;
 636 -    } else {
 637 -        return 2;
 638 -    }
 639 -}
 640 -
 641 -static inline uint32_t cc_calc_ltgt0_32(CPUS390XState *env, int32_t dst)
 642 -{
 643 -    return cc_calc_ltgt_32(env, dst, 0);
 644 -}
 645 -
 646 -static inline uint32_t cc_calc_ltgt_64(CPUS390XState *env, int64_t src,
 647 -                                       int64_t dst)
 648 -{
 649 -    if (src == dst) {
 650 -        return 0;
 651 -    } else if (src < dst) {
 652 -        return 1;
 653 -    } else {
 654 -        return 2;
 655 -    }
 656 -}
 657 -
 658 -static inline uint32_t cc_calc_ltgt0_64(CPUS390XState *env, int64_t dst)
 659 -{
 660 -    return cc_calc_ltgt_64(env, dst, 0);
 661 -}
 662 -
 663 -static inline uint32_t cc_calc_ltugtu_32(CPUS390XState *env, uint32_t src,
 664 -                                         uint32_t dst)
 665 -{
 666 -    if (src == dst) {
 667 -        return 0;
 668 -    } else if (src < dst) {
 669 -        return 1;
 670 -    } else {
 671 -        return 2;
 672 -    }
 673 -}
 674 -
 675 -static inline uint32_t cc_calc_ltugtu_64(CPUS390XState *env, uint64_t src,
 676 -                                         uint64_t dst)
 677 -{
 678 -    if (src == dst) {
 679 -        return 0;
 680 -    } else if (src < dst) {
 681 -        return 1;
 682 -    } else {
 683 -        return 2;
 684 -    }
 685 -}
 686 -
 687 -static inline uint32_t cc_calc_tm_32(CPUS390XState *env, uint32_t val,
 688 -                                     uint32_t mask)
 689 -{
 690 -    uint16_t r = val & mask;
 691 -
 692 -    HELPER_LOG("%s: val 0x%x mask 0x%x\n", __func__, val, mask);
 693 -    if (r == 0 || mask == 0) {
 694 -        return 0;
 695 -    } else if (r == mask) {
 696 -        return 3;
 697 -    } else {
 698 -        return 1;
 699 -    }
 700 -}
 701 -
 702 -/* set condition code for test under mask */
 703 -static inline uint32_t cc_calc_tm_64(CPUS390XState *env, uint64_t val,
 704 -                                     uint32_t mask)
 705 -{
 706 -    uint16_t r = val & mask;
 707 -
 708 -    HELPER_LOG("%s: val 0x%lx mask 0x%x r 0x%x\n", __func__, val, mask, r);
 709 -    if (r == 0 || mask == 0) {
 710 -        return 0;
 711 -    } else if (r == mask) {
 712 -        return 3;
 713 -    } else {
 714 -        while (!(mask & 0x8000)) {
 715 -            mask <<= 1;
 716 -            val <<= 1;
 717 -        }
 718 -        if (val & 0x8000) {
 719 -            return 2;
 720 -        } else {
 721 -            return 1;
 722 -        }
 723 -    }
 724 -}
 725 -
 726 -static inline uint32_t cc_calc_nz(CPUS390XState *env, uint64_t dst)
 727 -{
 728 -    return !!dst;
 729 -}
 730 -
 731 -static inline uint32_t cc_calc_add_64(CPUS390XState *env, int64_t a1,
 732 -                                      int64_t a2, int64_t ar)
 733 -{
 734 -    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 735 -        return 3; /* overflow */
 736 -    } else {
 737 -        if (ar < 0) {
 738 -            return 1;
 739 -        } else if (ar > 0) {
 740 -            return 2;
 741 -        } else {
 742 -            return 0;
 743 -        }
 744 -    }
 745 -}
 746 -
 747 -static inline uint32_t cc_calc_addu_64(CPUS390XState *env, uint64_t a1,
 748 -                                       uint64_t a2, uint64_t ar)
 749 -{
 750 -    if (ar == 0) {
 751 -        if (a1) {
 752 -            return 2;
 753 -        } else {
 754 -            return 0;
 755 -        }
 756 -    } else {
 757 -        if (ar < a1 || ar < a2) {
 758 -            return 3;
 759 -        } else {
 760 -            return 1;
 761 -        }
 762 -    }
 763 -}
 764 -
 765 -static inline uint32_t cc_calc_sub_64(CPUS390XState *env, int64_t a1,
 766 -                                      int64_t a2, int64_t ar)
 767 -{
 768 -    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 769 -        return 3; /* overflow */
 770 -    } else {
 771 -        if (ar < 0) {
 772 -            return 1;
 773 -        } else if (ar > 0) {
 774 -            return 2;
 775 -        } else {
 776 -            return 0;
 777 -        }
 778 -    }
 779 -}
 780 -
 781 -static inline uint32_t cc_calc_subu_64(CPUS390XState *env, uint64_t a1,
 782 -                                       uint64_t a2, uint64_t ar)
 783 -{
 784 -    if (ar == 0) {
 785 -        return 2;
 786 -    } else {
 787 -        if (a2 > a1) {
 788 -            return 1;
 789 -        } else {
 790 -            return 3;
 791 -        }
 792 -    }
 793 -}
 794 -
 795 -static inline uint32_t cc_calc_abs_64(CPUS390XState *env, int64_t dst)
 796 -{
 797 -    if ((uint64_t)dst == 0x8000000000000000ULL) {
 798 -        return 3;
 799 -    } else if (dst) {
 800 -        return 1;
 801 -    } else {
 802 -        return 0;
 803 -    }
 804 -}
 805 -
 806 -static inline uint32_t cc_calc_nabs_64(CPUS390XState *env, int64_t dst)
 807 -{
 808 -    return !!dst;
 809 -}
 810 -
 811 -static inline uint32_t cc_calc_comp_64(CPUS390XState *env, int64_t dst)
 812 -{
 813 -    if ((uint64_t)dst == 0x8000000000000000ULL) {
 814 -        return 3;
 815 -    } else if (dst < 0) {
 816 -        return 1;
 817 -    } else if (dst > 0) {
 818 -        return 2;
 819 -    } else {
 820 -        return 0;
 821 -    }
 822 -}
 823 -
 824 -
 825 -static inline uint32_t cc_calc_add_32(CPUS390XState *env, int32_t a1,
 826 -                                      int32_t a2, int32_t ar)
 827 -{
 828 -    if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 829 -        return 3; /* overflow */
 830 -    } else {
 831 -        if (ar < 0) {
 832 -            return 1;
 833 -        } else if (ar > 0) {
 834 -            return 2;
 835 -        } else {
 836 -            return 0;
 837 -        }
 838 -    }
 839 -}
 840 -
 841 -static inline uint32_t cc_calc_addu_32(CPUS390XState *env, uint32_t a1,
 842 -                                       uint32_t a2, uint32_t ar)
 843 -{
 844 -    if (ar == 0) {
 845 -        if (a1) {
 846 -            return 2;
 847 -        } else {
 848 -            return 0;
 849 -        }
 850 -    } else {
 851 -        if (ar < a1 || ar < a2) {
 852 -            return 3;
 853 -        } else {
 854 -            return 1;
 855 -        }
 856 -    }
 857 -}
 858 -
 859 -static inline uint32_t cc_calc_sub_32(CPUS390XState *env, int32_t a1,
 860 -                                      int32_t a2, int32_t ar)
 861 -{
 862 -    if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 863 -        return 3; /* overflow */
 864 -    } else {
 865 -        if (ar < 0) {
 866 -            return 1;
 867 -        } else if (ar > 0) {
 868 -            return 2;
 869 -        } else {
 870 -            return 0;
 871 -        }
 872 -    }
 873 -}
 874 -
 875 -static inline uint32_t cc_calc_subu_32(CPUS390XState *env, uint32_t a1,
 876 -                                       uint32_t a2, uint32_t ar)
 877 -{
 878 -    if (ar == 0) {
 879 -        return 2;
 880 -    } else {
 881 -        if (a2 > a1) {
 882 -            return 1;
 883 -        } else {
 884 -            return 3;
 885 -        }
 886 -    }
 887 -}
 888 -
 889 -static inline uint32_t cc_calc_abs_32(CPUS390XState *env, int32_t dst)
 890 -{
 891 -    if ((uint32_t)dst == 0x80000000UL) {
 892 -        return 3;
 893 -    } else if (dst) {
 894 -        return 1;
 895 -    } else {
 896 -        return 0;
 897 -    }
 898 -}
 899 -
 900 -static inline uint32_t cc_calc_nabs_32(CPUS390XState *env, int32_t dst)
 901 -{
 902 -    return !!dst;
 903 -}
 904 -
 905 -static inline uint32_t cc_calc_comp_32(CPUS390XState *env, int32_t dst)
 906 -{
 907 -    if ((uint32_t)dst == 0x80000000UL) {
 908 -        return 3;
 909 -    } else if (dst < 0) {
 910 -        return 1;
 911 -    } else if (dst > 0) {
 912 -        return 2;
 913 -    } else {
 914 -        return 0;
 915 -    }
 916 -}
 917 -
 918 -/* calculate condition code for insert character under mask insn */
 919 -static inline uint32_t cc_calc_icm_32(CPUS390XState *env, uint32_t mask,
 920 -                                      uint32_t val)
 921 -{
 922 -    uint32_t cc;
 923 -
 924 -    HELPER_LOG("%s: mask 0x%x val %d\n", __func__, mask, val);
 925 -    if (mask == 0xf) {
 926 -        if (!val) {
 927 -            return 0;
 928 -        } else if (val & 0x80000000) {
 929 -            return 1;
 930 -        } else {
 931 -            return 2;
 932 -        }
 933 -    }
 934 -
 935 -    if (!val || !mask) {
 936 -        cc = 0;
 937 -    } else {
 938 -        while (mask != 1) {
 939 -            mask >>= 1;
 940 -            val >>= 8;
 941 -        }
 942 -        if (val & 0x80) {
 943 -            cc = 1;
 944 -        } else {
 945 -            cc = 2;
 946 -        }
 947 -    }
 948 -    return cc;
 949 -}
 950 -
 951 -static inline uint32_t cc_calc_slag(CPUS390XState *env, uint64_t src,
 952 -                                    uint64_t shift)
 953 -{
 954 -    uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
 955 -    uint64_t match, r;
 956 -
 957 -    /* check if the sign bit stays the same */
 958 -    if (src & (1ULL << 63)) {
 959 -        match = mask;
 960 -    } else {
 961 -        match = 0;
 962 -    }
 963 -
 964 -    if ((src & mask) != match) {
 965 -        /* overflow */
 966 -        return 3;
 967 -    }
 968 -
 969 -    r = ((src << shift) & ((1ULL << 63) - 1)) | (src & (1ULL << 63));
 970 -
 971 -    if ((int64_t)r == 0) {
 972 -        return 0;
 973 -    } else if ((int64_t)r < 0) {
 974 -        return 1;
 975 -    }
 976 -
 977 -    return 2;
 978 -}
 979 -
 980 -
 981 -static inline uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
 982 -                                  uint64_t src, uint64_t dst, uint64_t vr)
 983 -{
 984 -    uint32_t r = 0;
 985 -
 986 -    switch (cc_op) {
 987 -    case CC_OP_CONST0:
 988 -    case CC_OP_CONST1:
 989 -    case CC_OP_CONST2:
 990 -    case CC_OP_CONST3:
 991 -        /* cc_op value _is_ cc */
 992 -        r = cc_op;
 993 -        break;
 994 -    case CC_OP_LTGT0_32:
 995 -        r = cc_calc_ltgt0_32(env, dst);
 996 -        break;
 997 -    case CC_OP_LTGT0_64:
 998 -        r =  cc_calc_ltgt0_64(env, dst);
 999 -        break;
1000 -    case CC_OP_LTGT_32:
1001 -        r =  cc_calc_ltgt_32(env, src, dst);
1002 -        break;
1003 -    case CC_OP_LTGT_64:
1004 -        r =  cc_calc_ltgt_64(env, src, dst);
1005 -        break;
1006 -    case CC_OP_LTUGTU_32:
1007 -        r =  cc_calc_ltugtu_32(env, src, dst);
1008 -        break;
1009 -    case CC_OP_LTUGTU_64:
1010 -        r =  cc_calc_ltugtu_64(env, src, dst);
1011 -        break;
1012 -    case CC_OP_TM_32:
1013 -        r =  cc_calc_tm_32(env, src, dst);
1014 -        break;
1015 -    case CC_OP_TM_64:
1016 -        r =  cc_calc_tm_64(env, src, dst);
1017 -        break;
1018 -    case CC_OP_NZ:
1019 -        r =  cc_calc_nz(env, dst);
1020 -        break;
1021 -    case CC_OP_ADD_64:
1022 -        r =  cc_calc_add_64(env, src, dst, vr);
1023 -        break;
1024 -    case CC_OP_ADDU_64:
1025 -        r =  cc_calc_addu_64(env, src, dst, vr);
1026 -        break;
1027 -    case CC_OP_SUB_64:
1028 -        r =  cc_calc_sub_64(env, src, dst, vr);
1029 -        break;
1030 -    case CC_OP_SUBU_64:
1031 -        r =  cc_calc_subu_64(env, src, dst, vr);
1032 -        break;
1033 -    case CC_OP_ABS_64:
1034 -        r =  cc_calc_abs_64(env, dst);
1035 -        break;
1036 -    case CC_OP_NABS_64:
1037 -        r =  cc_calc_nabs_64(env, dst);
1038 -        break;
1039 -    case CC_OP_COMP_64:
1040 -        r =  cc_calc_comp_64(env, dst);
1041 -        break;
1042 -
1043 -    case CC_OP_ADD_32:
1044 -        r =  cc_calc_add_32(env, src, dst, vr);
1045 -        break;
1046 -    case CC_OP_ADDU_32:
1047 -        r =  cc_calc_addu_32(env, src, dst, vr);
1048 -        break;
1049 -    case CC_OP_SUB_32:
1050 -        r =  cc_calc_sub_32(env, src, dst, vr);
1051 -        break;
1052 -    case CC_OP_SUBU_32:
1053 -        r =  cc_calc_subu_32(env, src, dst, vr);
1054 -        break;
1055 -    case CC_OP_ABS_32:
1056 -        r =  cc_calc_abs_64(env, dst);
1057 -        break;
1058 -    case CC_OP_NABS_32:
1059 -        r =  cc_calc_nabs_64(env, dst);
1060 -        break;
1061 -    case CC_OP_COMP_32:
1062 -        r =  cc_calc_comp_32(env, dst);
1063 -        break;
1064 -
1065 -    case CC_OP_ICM:
1066 -        r =  cc_calc_icm_32(env, src, dst);
1067 -        break;
1068 -    case CC_OP_SLAG:
1069 -        r =  cc_calc_slag(env, src, dst);
1070 -        break;
1071 -
1072 -    case CC_OP_LTGT_F32:
1073 -        r = set_cc_f32(src, dst);
1074 -        break;
1075 -    case CC_OP_LTGT_F64:
1076 -        r = set_cc_f64(src, dst);
1077 -        break;
1078 -    case CC_OP_NZ_F32:
1079 -        r = set_cc_nz_f32(dst);
1080 -        break;
1081 -    case CC_OP_NZ_F64:
1082 -        r = set_cc_nz_f64(dst);
1083 -        break;
1084 -
1085 -    default:
1086 -        cpu_abort(env, "Unknown CC operation: %s\n", cc_name(cc_op));
1087 -    }
1088 -
1089 -    HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
1090 -               cc_name(cc_op), src, dst, vr, r);
1091 -    return r;
1092 -}
1093 -
1094 -uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
1095 -                 uint64_t vr)
1096 -{
1097 -    return do_calc_cc(env, cc_op, src, dst, vr);
1098 -}
1099 -
1100 -uint32_t HELPER(calc_cc)(uint32_t cc_op, uint64_t src, uint64_t dst,
1101 -                         uint64_t vr)
1102 -{
1103 -    return do_calc_cc(env, cc_op, src, dst, vr);
1104 -}
1105 -
1106  uint64_t HELPER(cvd)(int32_t bin)
1107  {
1108      /* positive 0 */
1109 @@ -1594,14 +1105,7 @@ void HELPER(tr)(uint32_t len, uint64_t array, uint64_t trans)
1110  }
1111
1112  #ifndef CONFIG_USER_ONLY
1113 -
1114 -void HELPER(load_psw)(uint64_t mask, uint64_t addr)
1115 -{
1116 -    load_psw(env, mask, addr);
1117 -    cpu_loop_exit(env);
1118 -}
1119 -
1120 -static void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
1121 +void program_interrupt(CPUS390XState *env, uint32_t code, int ilc)
1122  {
1123      qemu_log("program interrupt at %#" PRIx64 "\n", env->psw.addr);
1124
1125 @@ -2175,30 +1679,6 @@ uint32_t HELPER(sigp)(uint64_t order_code, uint32_t r1, uint64_t cpu_addr)
1126      return cc;
1127  }
1128
1129 -void HELPER(sacf)(uint64_t a1)
1130 -{
1131 -    HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
1132 -
1133 -    switch (a1 & 0xf00) {
1134 -    case 0x000:
1135 -        env->psw.mask &= ~PSW_MASK_ASC;
1136 -        env->psw.mask |= PSW_ASC_PRIMARY;
1137 -        break;
1138 -    case 0x100:
1139 -        env->psw.mask &= ~PSW_MASK_ASC;
1140 -        env->psw.mask |= PSW_ASC_SECONDARY;
1141 -        break;
1142 -    case 0x300:
1143 -        env->psw.mask &= ~PSW_MASK_ASC;
1144 -        env->psw.mask |= PSW_ASC_HOME;
1145 -        break;
1146 -    default:
1147 -        qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
1148 -        program_interrupt(env, PGM_SPECIFICATION, 2);
1149 -        break;
1150 -    }
1151 -}
1152 -
1153  /* invalidate pte */
1154  void HELPER(ipte)(uint64_t pte_addr, uint64_t vaddr)
1155  {
1156 --
1157 1.7.12.1
1158