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