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 #include "qemu/host-utils.h"
  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
  32 static uint32_t cc_calc_ltgt_32(int32_t src, 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 uint32_t cc_calc_ltgt0_32(int32_t dst)
  44 {
  45     return cc_calc_ltgt_32(dst, 0);
  46 }
  47
  48 static uint32_t cc_calc_ltgt_64(int64_t src, int64_t dst)
  49 {
  50     if (src == dst) {
  51         return 0;
  52     } else if (src < dst) {
  53         return 1;
  54     } else {
  55         return 2;
  56     }
  57 }
  58
  59 static uint32_t cc_calc_ltgt0_64(int64_t dst)
  60 {
  61     return cc_calc_ltgt_64(dst, 0);
  62 }
  63
  64 static uint32_t cc_calc_ltugtu_32(uint32_t src, uint32_t dst)
  65 {
  66     if (src == dst) {
  67         return 0;
  68     } else if (src < dst) {
  69         return 1;
  70     } else {
  71         return 2;
  72     }
  73 }
  74
  75 static uint32_t cc_calc_ltugtu_64(uint64_t src, uint64_t dst)
  76 {
  77     if (src == dst) {
  78         return 0;
  79     } else if (src < dst) {
  80         return 1;
  81     } else {
  82         return 2;
  83     }
  84 }
  85
  86 static uint32_t cc_calc_tm_32(uint32_t val, uint32_t mask)
  87 {
  88     uint32_t r = val & mask;
  89
  90     if (r == 0) {
  91         return 0;
  92     } else if (r == mask) {
  93         return 3;
  94     } else {
  95         return 1;
  96     }
  97 }
  98
  99 static uint32_t cc_calc_tm_64(uint64_t val, uint64_t mask)
 100 {
 101     uint64_t r = val & mask;
 102
 103     if (r == 0) {
 104         return 0;
 105     } else if (r == mask) {
 106         return 3;
 107     } else {
 108         int top = clz64(mask);
 109         if ((int64_t)(val << top) < 0) {
 110             return 2;
 111         } else {
 112             return 1;
 113         }
 114     }
 115 }
 116
 117 static uint32_t cc_calc_nz(uint64_t dst)
 118 {
 119     return !!dst;
 120 }
 121
 122 static uint32_t cc_calc_add_64(int64_t a1, int64_t a2, int64_t ar)
 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
 137 static uint32_t cc_calc_addu_64(uint64_t a1, uint64_t a2, uint64_t ar)
 138 {
 139     return (ar != 0) + 2 * (ar < a1);
 140 }
 141
 142 static uint32_t cc_calc_addc_64(uint64_t a1, uint64_t a2, uint64_t ar)
 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;
 150 }
 151
 152 static uint32_t cc_calc_sub_64(int64_t a1, int64_t a2, int64_t ar)
 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
 167 static uint32_t cc_calc_subu_64(uint64_t a1, uint64_t a2, uint64_t ar)
 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
 180 static uint32_t cc_calc_subb_64(uint64_t a1, uint64_t a2, uint64_t ar)
 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
 198 static uint32_t cc_calc_abs_64(int64_t dst)
 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
 209 static uint32_t cc_calc_nabs_64(int64_t dst)
 210 {
 211     return !!dst;
 212 }
 213
 214 static uint32_t cc_calc_comp_64(int64_t dst)
 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
 228 static uint32_t cc_calc_add_32(int32_t a1, int32_t a2, int32_t ar)
 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
 243 static uint32_t cc_calc_addu_32(uint32_t a1, uint32_t a2, uint32_t ar)
 244 {
 245     return (ar != 0) + 2 * (ar < a1);
 246 }
 247
 248 static uint32_t cc_calc_addc_32(uint32_t a1, uint32_t a2, uint32_t ar)
 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;
 256 }
 257
 258 static uint32_t cc_calc_sub_32(int32_t a1, int32_t a2, int32_t ar)
 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
 273 static uint32_t cc_calc_subu_32(uint32_t a1, uint32_t a2, uint32_t ar)
 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
 286 static uint32_t cc_calc_subb_32(uint32_t a1, uint32_t a2, uint32_t ar)
 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
 304 static uint32_t cc_calc_abs_32(int32_t dst)
 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
 315 static uint32_t cc_calc_nabs_32(int32_t dst)
 316 {
 317     return !!dst;
 318 }
 319
 320 static uint32_t cc_calc_comp_32(int32_t dst)
 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 */
 334 static uint32_t cc_calc_icm_32(uint32_t mask, uint32_t val)
 335 {
 336     uint32_t cc;
 337
 338     HELPER_LOG("%s: mask 0x%x val %d\n", __func__, mask, val);
 339     if (mask == 0xf) {
 340         if (!val) {
 341             return 0;
 342         } else if (val & 0x80000000) {
 343             return 1;
 344         } else {
 345             return 2;
 346         }
 347     }
 348
 349     if (!val || !mask) {
 350         cc = 0;
 351     } else {
 352         while (mask != 1) {
 353             mask >>= 1;
 354             val >>= 8;
 355         }
 356         if (val & 0x80) {
 357             cc = 1;
 358         } else {
 359             cc = 2;
 360         }
 361     }
 362     return cc;
 363 }
 364
 365 static uint32_t cc_calc_slag(uint64_t src, uint64_t shift)
 366 {
 367     uint64_t mask = ((1ULL << shift) - 1ULL) << (64 - shift);
 368     uint64_t match, r;
 369
 370     /* check if the sign bit stays the same */
 371     if (src & (1ULL << 63)) {
 372         match = mask;
 373     } else {
 374         match = 0;
 375     }
 376
 377     if ((src & mask) != match) {
 378         /* overflow */
 379         return 3;
 380     }
 381
 382     r = ((src << shift) & ((1ULL << 63) - 1)) | (src & (1ULL << 63));
 383
 384     if ((int64_t)r == 0) {
 385         return 0;
 386     } else if ((int64_t)r < 0) {
 387         return 1;
 388     }
 389
 390     return 2;
 391 }
 392
 393
 394 static uint32_t do_calc_cc(CPUS390XState *env, uint32_t cc_op,
 395                                   uint64_t src, uint64_t dst, uint64_t vr)
 396 {
 397     uint32_t r = 0;
 398
 399     switch (cc_op) {
 400     case CC_OP_CONST0:
 401     case CC_OP_CONST1:
 402     case CC_OP_CONST2:
 403     case CC_OP_CONST3:
 404         /* cc_op value _is_ cc */
 405         r = cc_op;
 406         break;
 407     case CC_OP_LTGT0_32:
 408         r = cc_calc_ltgt0_32(dst);
 409         break;
 410     case CC_OP_LTGT0_64:
 411         r =  cc_calc_ltgt0_64(dst);
 412         break;
 413     case CC_OP_LTGT_32:
 414         r =  cc_calc_ltgt_32(src, dst);
 415         break;
 416     case CC_OP_LTGT_64:
 417         r =  cc_calc_ltgt_64(src, dst);
 418         break;
 419     case CC_OP_LTUGTU_32:
 420         r =  cc_calc_ltugtu_32(src, dst);
 421         break;
 422     case CC_OP_LTUGTU_64:
 423         r =  cc_calc_ltugtu_64(src, dst);
 424         break;
 425     case CC_OP_TM_32:
 426         r =  cc_calc_tm_32(src, dst);
 427         break;
 428     case CC_OP_TM_64:
 429         r =  cc_calc_tm_64(src, dst);
 430         break;
 431     case CC_OP_NZ:
 432         r =  cc_calc_nz(dst);
 433         break;
 434     case CC_OP_ADD_64:
 435         r =  cc_calc_add_64(src, dst, vr);
 436         break;
 437     case CC_OP_ADDU_64:
 438         r =  cc_calc_addu_64(src, dst, vr);
 439         break;
 440     case CC_OP_ADDC_64:
 441         r =  cc_calc_addc_64(src, dst, vr);
 442         break;
 443     case CC_OP_SUB_64:
 444         r =  cc_calc_sub_64(src, dst, vr);
 445         break;
 446     case CC_OP_SUBU_64:
 447         r =  cc_calc_subu_64(src, dst, vr);
 448         break;
 449     case CC_OP_SUBB_64:
 450         r =  cc_calc_subb_64(src, dst, vr);
 451         break;
 452     case CC_OP_ABS_64:
 453         r =  cc_calc_abs_64(dst);
 454         break;
 455     case CC_OP_NABS_64:
 456         r =  cc_calc_nabs_64(dst);
 457         break;
 458     case CC_OP_COMP_64:
 459         r =  cc_calc_comp_64(dst);
 460         break;
 461
 462     case CC_OP_ADD_32:
 463         r =  cc_calc_add_32(src, dst, vr);
 464         break;
 465     case CC_OP_ADDU_32:
 466         r =  cc_calc_addu_32(src, dst, vr);
 467         break;
 468     case CC_OP_ADDC_32:
 469         r =  cc_calc_addc_32(src, dst, vr);
 470         break;
 471     case CC_OP_SUB_32:
 472         r =  cc_calc_sub_32(src, dst, vr);
 473         break;
 474     case CC_OP_SUBU_32:
 475         r =  cc_calc_subu_32(src, dst, vr);
 476         break;
 477     case CC_OP_SUBB_32:
 478         r =  cc_calc_subb_32(src, dst, vr);
 479         break;
 480     case CC_OP_ABS_32:
 481         r =  cc_calc_abs_32(dst);
 482         break;
 483     case CC_OP_NABS_32:
 484         r =  cc_calc_nabs_32(dst);
 485         break;
 486     case CC_OP_COMP_32:
 487         r =  cc_calc_comp_32(dst);
 488         break;
 489
 490     case CC_OP_ICM:
 491         r =  cc_calc_icm_32(src, dst);
 492         break;
 493     case CC_OP_SLAG:
 494         r =  cc_calc_slag(src, dst);
 495         break;
 496
 497     case CC_OP_LTGT_F32:
 498         r = set_cc_f32(env, src, dst);
 499         break;
 500     case CC_OP_LTGT_F64:
 501         r = set_cc_f64(env, src, dst);
 502         break;
 503     case CC_OP_NZ_F32:
 504         r = set_cc_nz_f32(dst);
 505         break;
 506     case CC_OP_NZ_F64:
 507         r = set_cc_nz_f64(dst);
 508         break;
 509
 510     default:
 511         cpu_abort(env, "Unknown CC operation: %s\n", cc_name(cc_op));
 512     }
 513
 514     HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d\n", __func__,
 515                cc_name(cc_op), src, dst, vr, r);
 516     return r;
 517 }
 518
 519 uint32_t calc_cc(CPUS390XState *env, uint32_t cc_op, uint64_t src, uint64_t dst,
 520                  uint64_t vr)
 521 {
 522     return do_calc_cc(env, cc_op, src, dst, vr);
 523 }
 524
 525 uint32_t HELPER(calc_cc)(CPUS390XState *env, uint32_t cc_op, uint64_t src,
 526                          uint64_t dst, uint64_t vr)
 527 {
 528     return do_calc_cc(env, cc_op, src, dst, vr);
 529 }
 530
 531 /* insert psw mask and condition code into r1 */
 532 void HELPER(ipm)(CPUS390XState *env, uint32_t cc, uint32_t r1)
 533 {
 534     uint64_t r = env->regs[r1];
 535
 536     r &= 0xffffffff00ffffffULL;
 537     r |= (cc << 28) | ((env->psw.mask >> 40) & 0xf);
 538     env->regs[r1] = r;
 539     HELPER_LOG("%s: cc %d psw.mask 0x%lx r1 0x%lx\n", __func__,
 540                cc, env->psw.mask, r);
 541 }
 542
 543 #ifndef CONFIG_USER_ONLY
 544 void HELPER(load_psw)(CPUS390XState *env, uint64_t mask, uint64_t addr)
 545 {
 546     load_psw(env, mask, addr);
 547     cpu_loop_exit(env);
 548 }
 549
 550 void HELPER(sacf)(CPUS390XState *env, uint64_t a1)
 551 {
 552     HELPER_LOG("%s: %16" PRIx64 "\n", __func__, a1);
 553
 554     switch (a1 & 0xf00) {
 555     case 0x000:
 556         env->psw.mask &= ~PSW_MASK_ASC;
 557         env->psw.mask |= PSW_ASC_PRIMARY;
 558         break;
 559     case 0x100:
 560         env->psw.mask &= ~PSW_MASK_ASC;
 561         env->psw.mask |= PSW_ASC_SECONDARY;
 562         break;
 563     case 0x300:
 564         env->psw.mask &= ~PSW_MASK_ASC;
 565         env->psw.mask |= PSW_ASC_HOME;
 566         break;
 567     default:
 568         qemu_log("unknown sacf mode: %" PRIx64 "\n", a1);
 569         program_interrupt(env, PGM_SPECIFICATION, 2);
 570         break;
 571     }
 572 }
 573 #endif