target/s390x/cc_helper.c

   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.1 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 "qemu/osdep.h"
  22 #include "cpu.h"
  23 #include "internal.h"
  24 #include "tcg_s390x.h"
  25 #include "exec/exec-all.h"
  26 #include "exec/helper-proto.h"
  27 #include "qemu/host-utils.h"
  28
  29 /* #define DEBUG_HELPER */
  30 #ifdef DEBUG_HELPER
  31 #define HELPER_LOG(x...) qemu_log(x)
  32 #else
  33 #define HELPER_LOG(x...)
  34 #endif
  35
  36 static uint32_t cc_calc_ltgt_32(int32_t src, int32_t dst)
  37 {
  38     if (src == dst) {
  39         return 0;
  40     } else if (src < dst) {
  41         return 1;
  42     } else {
  43         return 2;
  44     }
  45 }
  46
  47 static uint32_t cc_calc_ltgt0_32(int32_t dst)
  48 {
  49     return cc_calc_ltgt_32(dst, 0);
  50 }
  51
  52 static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
  53 {
  54     if (src == dst) {
  55         return 0;
  56     } else if (src < dst) {
  57         return 1;
  58     } else {
  59         return 2;
  60     }
  61 }
  62
  63 static uint32_t cc_calc_ltgt0_64(int64_t dst)
  64 {
  65     return cc_calc_ltgt_64(dst, 0);
  66 }
  67
  68 static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
  69 {
  70     if (src == dst) {
  71         return 0;
  72     } else if (src < dst) {
  73         return 1;
  74     } else {
  75         return 2;
  76     }
  77 }
  78
  79 static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
  80 {
  81     if (src == dst) {
  82         return 0;
  83     } else if (src < dst) {
  84         return 1;
  85     } else {
  86         return 2;
  87     }
  88 }
  89
  90 static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
  91 {
  92     uint32_t r = val & mask;
  93
  94     if (r == 0) {
  95         return 0;
  96     } else if (r == mask) {
  97         return 3;
  98     } else {
  99         return 1;
 100     }
 101 }
 102
 103 static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
 104 {
 105     uint64_t r = val & mask;
 106
 107     if (r == 0) {
 108         return 0;
 109     } else if (r == mask) {
 110         return 3;
 111     } else {
 112         int top = clz64(mask);
 113         if ((int64_t)(val << top) < 0) {
 114             return 2;
 115         } else {
 116             return 1;
 117         }
 118     }
 119 }
 120
 121 static uint32_t cc_calc_nz(uint64_t dst)
 122 {
 123     return !!dst;
 124 }
 125
 126 static uint32_t cc_calc_addu(uint64_t carry_out, uint64_t result)
 127 {
 128     g_assert(carry_out <= 1);
 129     return (result != 0) + 2 * carry_out;
 130 }
 131
 132 static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
 133 {
 134     if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 135         return 3; /* overflow */
 136     } else {
 137         if (ar < 0) {
 138             return 1;
 139         } else if (ar > 0) {
 140             return 2;
 141         } else {
 142             return 0;
 143         }
 144     }
 145 }
 146
 147 static uint32_t cc_calc_sub_64(int64_t a1, int64_t a2, int64_t ar)
 148 {
 149     if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 150         return 3; /* overflow */
 151     } else {
 152         if (ar < 0) {
 153             return 1;
 154         } else if (ar > 0) {
 155             return 2;
 156         } else {
 157             return 0;
 158         }
 159     }
 160 }
 161
 162 static uint32_t cc_calc_subu_64(uint64_t a1, uint64_t a2, uint64_t ar)
 163 {
 164     if (ar == 0) {
 165         return 2;
 166     } else {
 167         if (a2 > a1) {
 168             return 1;
 169         } else {
 170             return 3;
 171         }
 172     }
 173 }
 174
 175 static uint32_t cc_calc_subb_64(uint64_t a1, uint64_t a2, uint64_t ar)
 176 {
 177     int borrow_out;
 178
 179     if (ar != a1 - a2) {        /* difference means borrow-in */
 180         borrow_out = (a2 >= a1);
 181     } else {
 182         borrow_out = (a2 > a1);
 183     }
 184
 185     return (ar != 0) + 2 * !borrow_out;
 186 }
 187
 188 static uint32_t cc_calc_abs_64(int64_t dst)
 189 {
 190     if ((uint64_t)dst == 0x8000000000000000ULL) {
 191         return 3;
 192     } else if (dst) {
 193         return 2;
 194     } else {
 195         return 0;
 196     }
 197 }
 198
 199 static uint32_t cc_calc_nabs_64(int64_t dst)
 200 {
 201     return !!dst;
 202 }
 203
 204 static uint32_t cc_calc_comp_64(int64_t dst)
 205 {
 206     if ((uint64_t)dst == 0x8000000000000000ULL) {
 207         return 3;
 208     } else if (dst < 0) {
 209         return 1;
 210     } else if (dst > 0) {
 211         return 2;
 212     } else {
 213         return 0;
 214     }
 215 }
 216
 217
 218 static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
 219 {
 220     if ((a1 > 0 && a2 > 0 && ar < 0) || (a1 < 0 && a2 < 0 && ar > 0)) {
 221         return 3; /* overflow */
 222     } else {
 223         if (ar < 0) {
 224             return 1;
 225         } else if (ar > 0) {
 226             return 2;
 227         } else {
 228             return 0;
 229         }
 230     }
 231 }
 232
 233 static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
 234 {
 235     if ((a1 > 0 && a2 < 0 && ar < 0) || (a1 < 0 && a2 > 0 && ar > 0)) {
 236         return 3; /* overflow */
 237     } else {
 238         if (ar < 0) {
 239             return 1;
 240         } else if (ar > 0) {
 241             return 2;
 242         } else {
 243             return 0;
 244         }
 245     }
 246 }
 247
 248 static uint32_t cc_calc_subu_32(uint32_t a1, uint32_t a2, uint32_t ar)
 249 {
 250     if (ar == 0) {
 251         return 2;
 252     } else {
 253         if (a2 > a1) {
 254             return 1;
 255         } else {
 256             return 3;
 257         }
 258     }
 259 }
 260
 261 static uint32_t cc_calc_subb_32(uint32_t a1, uint32_t a2, uint32_t ar)
 262 {
 263     int borrow_out;
 264
 265     if (ar != a1 - a2) {        /* difference means borrow-in */
 266         borrow_out = (a2 >= a1);
 267     } else {
 268         borrow_out = (a2 > a1);
 269     }
 270
 271     return (ar != 0) + 2 * !borrow_out;
 272 }
 273
 274 static uint32_t cc_calc_abs_32(int32_t dst)
 275 {
 276     if ((uint32_t)dst == 0x80000000UL) {
 277         return 3;
 278     } else if (dst) {
 279         return 2;
 280     } else {
 281         return 0;
 282     }
 283 }
 284
 285 static uint32_t cc_calc_nabs_32(int32_t dst)
 286 {
 287     return !!dst;
 288 }
 289
 290 static uint32_t cc_calc_comp_32(int32_t dst)
 291 {
 292     if ((uint32_t)dst == 0x80000000UL) {
 293         return 3;
 294     } else if (dst < 0) {
 295         return 1;
 296     } else if (dst > 0) {
 297         return 2;
 298     } else {
 299         return 0;
 300     }
 301 }
 302
 303 /* calculate condition code for insert character under mask insn */
 304 static uint32_t cc_calc_icm(uint64_t mask, uint64_t val)
 305 {
 306     if ((val & mask) == 0) {
 307         return 0;
 308     } else {
 309         int top = clz64(mask);
 310         if ((int64_t)(val << top) < 0) {
 311             return 1;
 312         } else {
 313             return 2;
 314         }
 315     }
 316 }
 317
 318 static uint32_t cc_calc_sla_32(uint32_t src, int shift)
 319 {
 320     uint32_t mask = ((1U << shift) - 1U) << (32 - shift);
 321     uint32_t sign = 1U << 31;
 322     uint32_t match;
 323     int32_t r;
 324
 325     /* Check if the sign bit stays the same.  */
 326     if (src & sign) {
 327         match = mask;
 328     } else {
 329         match = 0;
 330     }
 331     if ((src & mask) != match) {
 332         /* Overflow.  */
 333         return 3;
 334     }
 335
 336     r = ((src << shift) & ~sign) | (src & sign);
 337     if (r == 0) {
 338         return 0;
 339     } else if (r < 0) {
 340         return 1;
 341     }
 342     return 2;
 343 }
 344
 345 static uint32_t cc_calc_sla_64(uint64_t src, int shift)
 346 {
 347     uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
 348     uint64_t sign = 1ULL << 63;
 349     uint64_t match;
 350     int64_t r;
 351
 352     /* Check if the sign bit stays the same.  */
 353     if (src & sign) {
 354         match = mask;
 355     } else {
 356         match = 0;
 357     }
 358     if ((src & mask) != match) {
 359         /* Overflow.  */
 360         return 3;
 361     }
 362
 363     r = ((src << shift) & ~sign) | (src & sign);
 364     if (r == 0) {
 365         return 0;
 366     } else if (r < 0) {
 367         return 1;
 368     }
 369     return 2;
 370 }
 371
 372 static uint32_t cc_calc_flogr(uint64_t dst)
 373 {
 374     return dst ? 2 : 0;
 375 }
 376
 377 static uint32_t cc_calc_lcbb(uint64_t dst)
 378 {
 379     return dst == 16 ? 0 : 3;
 380 }
 381
 382 static uint32_t cc_calc_vc(uint64_t low, uint64_t high)
 383 {
 384     if (high == -1ull && low == -1ull) {
 385         /* all elements match */
 386         return 0;
 387     } else if (high == 0 && low == 0) {
 388         /* no elements match */
 389         return 3;
 390     } else {
 391         /* some elements but not all match */
 392         return 1;
 393     }
 394 }
 395
 396 static uint32_t cc_calc_muls_32(int64_t res)
 397 {
 398     const int64_t tmp = res >> 31;
 399
 400     if (!res) {
 401         return 0;
 402     } else if (tmp && tmp != -1) {
 403         return 3;
 404     } else if (res < 0) {
 405         return 1;
 406     }
 407     return 2;
 408 }
 409
 410 static uint64_t cc_calc_muls_64(int64_t res_high, uint64_t res_low)
 411 {
 412     if (!res_high && !res_low) {
 413         return 0;
 414     } else if (res_high + (res_low >> 63) != 0) {
 415         return 3;
 416     } else if (res_high < 0) {
 417         return 1;
 418     }
 419     return 2;
 420 }
 421
 422 static 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(dst);
 437         break;
 438     case CC_OP_LTGT0_64:
 439         r =  cc_calc_ltgt0_64(dst);
 440         break;
 441     case CC_OP_LTGT_32:
 442         r =  cc_calc_ltgt_32(src, dst);
 443         break;
 444     case CC_OP_LTGT_64:
 445         r =  cc_calc_ltgt_64(src, dst);
 446         break;
 447     case CC_OP_LTUGTU_32:
 448         r =  cc_calc_ltugtu_32(src, dst);
 449         break;
 450     case CC_OP_LTUGTU_64:
 451         r =  cc_calc_ltugtu_64(src, dst);
 452         break;
 453     case CC_OP_TM_32:
 454         r =  cc_calc_tm_32(src, dst);
 455         break;
 456     case CC_OP_TM_64:
 457         r =  cc_calc_tm_64(src, dst);
 458         break;
 459     case CC_OP_NZ:
 460         r =  cc_calc_nz(dst);
 461         break;
 462     case CC_OP_ADDU:
 463         r = cc_calc_addu(src, dst);
 464         break;
 465     case CC_OP_ADD_64:
 466         r =  cc_calc_add_64(src, dst, vr);
 467         break;
 468     case CC_OP_SUB_64:
 469         r =  cc_calc_sub_64(src, dst, vr);
 470         break;
 471     case CC_OP_SUBU_64:
 472         r =  cc_calc_subu_64(src, dst, vr);
 473         break;
 474     case CC_OP_SUBB_64:
 475         r =  cc_calc_subb_64(src, dst, vr);
 476         break;
 477     case CC_OP_ABS_64:
 478         r =  cc_calc_abs_64(dst);
 479         break;
 480     case CC_OP_NABS_64:
 481         r =  cc_calc_nabs_64(dst);
 482         break;
 483     case CC_OP_COMP_64:
 484         r =  cc_calc_comp_64(dst);
 485         break;
 486     case CC_OP_MULS_64:
 487         r = cc_calc_muls_64(src, dst);
 488         break;
 489
 490     case CC_OP_ADD_32:
 491         r =  cc_calc_add_32(src, dst, vr);
 492         break;
 493     case CC_OP_SUB_32:
 494         r =  cc_calc_sub_32(src, dst, vr);
 495         break;
 496     case CC_OP_SUBU_32:
 497         r =  cc_calc_subu_32(src, dst, vr);
 498         break;
 499     case CC_OP_SUBB_32:
 500         r =  cc_calc_subb_32(src, dst, vr);
 501         break;
 502     case CC_OP_ABS_32:
 503         r =  cc_calc_abs_32(dst);
 504         break;
 505     case CC_OP_NABS_32:
 506         r =  cc_calc_nabs_32(dst);
 507         break;
 508     case CC_OP_COMP_32:
 509         r =  cc_calc_comp_32(dst);
 510         break;
 511     case CC_OP_MULS_32:
 512         r = cc_calc_muls_32(dst);
 513         break;
 514
 515     case CC_OP_ICM:
 516         r =  cc_calc_icm(src, dst);
 517         break;
 518     case CC_OP_SLA_32:
 519         r =  cc_calc_sla_32(src, dst);
 520         break;
 521     case CC_OP_SLA_64:
 522         r =  cc_calc_sla_64(src, dst);
 523         break;
 524     case CC_OP_FLOGR:
 525         r = cc_calc_flogr(dst);
 526         break;
 527     case CC_OP_LCBB:
 528         r = cc_calc_lcbb(dst);
 529         break;
 530     case CC_OP_VC:
 531         r = cc_calc_vc(src, dst);
 532         break;
 533
 534     case CC_OP_NZ_F32:
 535         r = set_cc_nz_f32(dst);
 536         break;
 537     case CC_OP_NZ_F64:
 538         r = set_cc_nz_f64(dst);
 539         break;
 540     case CC_OP_NZ_F128:
 541         r = set_cc_nz_f128(make_float128(src, dst));
 542         break;
 543
 544     default:
 545         cpu_abort(env_cpu(env), "Unknown CC operation: %s\n", cc_name(cc_op));
 546     }
 547
 548     HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
 549                cc_name(cc_op), src, dst, vr, r);
 550     return r;
 551 }
 552
 553 uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
 554                  uint64_t vr)
 555 {
 556     return do_calc_cc(env, cc_op, src, dst, vr);
 557 }
 558
 559 uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
 560                          uint64_t dst, uint64_t vr)
 561 {
 562     return do_calc_cc(env, cc_op, src, dst, vr);
 563 }
 564
 565 #ifndef CONFIG_USER_ONLY
 566 void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
 567 {
 568     load_psw(env, mask, addr);
 569     cpu_loop_exit(env_cpu(env));
 570 }
 571
 572 void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
 573 {
 574     HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
 575
 576     switch (a1 & 0xf00) {
 577     case 0x000:
 578         env->psw.mask &= ~PSW_MASK_ASC;
 579         env->psw.mask |= PSW_ASC_PRIMARY;
 580         break;
 581     case 0x100:
 582         env->psw.mask &= ~PSW_MASK_ASC;
 583         env->psw.mask |= PSW_ASC_SECONDARY;
 584         break;
 585     case 0x300:
 586         env->psw.mask &= ~PSW_MASK_ASC;
 587         env->psw.mask |= PSW_ASC_HOME;
 588         break;
 589     default:
 590         HELPER_LOG("unknown sacf mode: %" PRIx64 "\n", a1);
 591         tcg_s390_program_interrupt(env, PGM_SPECIFICATION, GETPC());
 592     }
 593 }
 594 #endif