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