Fix libvirt + seccomp combo (bz #855162) Fix scsi hotplug crash (bz #879657) Fix QOM refcount crash (bz #881486)
445 lines
11 KiB
Diff
445 lines
11 KiB
Diff
From e9f67c1f326a995ff0000a08a223435386867d8f Mon Sep 17 00:00:00 2001
|
|
From: Blue Swirl <blauwirbel@gmail.com>
|
|
Date: Sun, 2 Sep 2012 07:33:33 +0000
|
|
Subject: [PATCH] target-s390x: split integer helpers
|
|
|
|
Move integer helpers to int_helper.c.
|
|
|
|
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
|
|
Signed-off-by: Alexander Graf <agraf@suse.de>
|
|
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
|
|
---
|
|
target-s390x/Makefile.objs | 3 +-
|
|
target-s390x/int_helper.c | 201 +++++++++++++++++++++++++++++++++++++++++++++
|
|
target-s390x/op_helper.c | 170 --------------------------------------
|
|
3 files changed, 203 insertions(+), 171 deletions(-)
|
|
create mode 100644 target-s390x/int_helper.c
|
|
|
|
diff --git a/target-s390x/Makefile.objs b/target-s390x/Makefile.objs
|
|
index f9437d6..e8f66e9 100644
|
|
--- a/target-s390x/Makefile.objs
|
|
+++ b/target-s390x/Makefile.objs
|
|
@@ -1,8 +1,9 @@
|
|
obj-y += translate.o op_helper.o helper.o cpu.o interrupt.o
|
|
-obj-y += fpu_helper.o cc_helper.o
|
|
+obj-y += int_helper.o fpu_helper.o cc_helper.o
|
|
obj-$(CONFIG_SOFTMMU) += machine.o
|
|
obj-$(CONFIG_KVM) += kvm.o
|
|
|
|
$(obj)/op_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
|
|
+$(obj)/int_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
|
|
$(obj)/fpu_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
|
|
$(obj)/cc_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
|
|
diff --git a/target-s390x/int_helper.c b/target-s390x/int_helper.c
|
|
new file mode 100644
|
|
index 0000000..e2eeb07
|
|
--- /dev/null
|
|
+++ b/target-s390x/int_helper.c
|
|
@@ -0,0 +1,201 @@
|
|
+/*
|
|
+ * S/390 integer helper routines
|
|
+ *
|
|
+ * Copyright (c) 2009 Ulrich Hecht
|
|
+ * Copyright (c) 2009 Alexander Graf
|
|
+ *
|
|
+ * This library is free software; you can redistribute it and/or
|
|
+ * modify it under the terms of the GNU Lesser General Public
|
|
+ * License as published by the Free Software Foundation; either
|
|
+ * version 2 of the License, or (at your option) any later version.
|
|
+ *
|
|
+ * This library is distributed in the hope that it will be useful,
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
+ * Lesser General Public License for more details.
|
|
+ *
|
|
+ * You should have received a copy of the GNU Lesser General Public
|
|
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
+ */
|
|
+
|
|
+#include "cpu.h"
|
|
+#include "dyngen-exec.h"
|
|
+#include "host-utils.h"
|
|
+#include "helper.h"
|
|
+
|
|
+/* #define DEBUG_HELPER */
|
|
+#ifdef DEBUG_HELPER
|
|
+#define HELPER_LOG(x...) qemu_log(x)
|
|
+#else
|
|
+#define HELPER_LOG(x...)
|
|
+#endif
|
|
+
|
|
+/* 64/64 -> 128 unsigned multiplication */
|
|
+void HELPER(mlg)(uint32_t r1, uint64_t v2)
|
|
+{
|
|
+#if HOST_LONG_BITS == 64 && defined(__GNUC__)
|
|
+ /* assuming 64-bit hosts have __uint128_t */
|
|
+ __uint128_t res = (__uint128_t)env->regs[r1 + 1];
|
|
+
|
|
+ res *= (__uint128_t)v2;
|
|
+ env->regs[r1] = (uint64_t)(res >> 64);
|
|
+ env->regs[r1 + 1] = (uint64_t)res;
|
|
+#else
|
|
+ mulu64(&env->regs[r1 + 1], &env->regs[r1], env->regs[r1 + 1], v2);
|
|
+#endif
|
|
+}
|
|
+
|
|
+/* 128 -> 64/64 unsigned division */
|
|
+void HELPER(dlg)(uint32_t r1, uint64_t v2)
|
|
+{
|
|
+ uint64_t divisor = v2;
|
|
+
|
|
+ if (!env->regs[r1]) {
|
|
+ /* 64 -> 64/64 case */
|
|
+ env->regs[r1] = env->regs[r1 + 1] % divisor;
|
|
+ env->regs[r1 + 1] = env->regs[r1 + 1] / divisor;
|
|
+ return;
|
|
+ } else {
|
|
+#if HOST_LONG_BITS == 64 && defined(__GNUC__)
|
|
+ /* assuming 64-bit hosts have __uint128_t */
|
|
+ __uint128_t dividend = (((__uint128_t)env->regs[r1]) << 64) |
|
|
+ (env->regs[r1 + 1]);
|
|
+ __uint128_t quotient = dividend / divisor;
|
|
+ __uint128_t remainder = dividend % divisor;
|
|
+
|
|
+ env->regs[r1 + 1] = quotient;
|
|
+ env->regs[r1] = remainder;
|
|
+#else
|
|
+ /* 32-bit hosts would need special wrapper functionality - just abort if
|
|
+ we encounter such a case; it's very unlikely anyways. */
|
|
+ cpu_abort(env, "128 -> 64/64 division not implemented\n");
|
|
+#endif
|
|
+ }
|
|
+}
|
|
+
|
|
+/* absolute value 32-bit */
|
|
+uint32_t HELPER(abs_i32)(int32_t val)
|
|
+{
|
|
+ if (val < 0) {
|
|
+ return -val;
|
|
+ } else {
|
|
+ return val;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* negative absolute value 32-bit */
|
|
+int32_t HELPER(nabs_i32)(int32_t val)
|
|
+{
|
|
+ if (val < 0) {
|
|
+ return val;
|
|
+ } else {
|
|
+ return -val;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* absolute value 64-bit */
|
|
+uint64_t HELPER(abs_i64)(int64_t val)
|
|
+{
|
|
+ HELPER_LOG("%s: val 0x%" PRIx64 "\n", __func__, val);
|
|
+
|
|
+ if (val < 0) {
|
|
+ return -val;
|
|
+ } else {
|
|
+ return val;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* negative absolute value 64-bit */
|
|
+int64_t HELPER(nabs_i64)(int64_t val)
|
|
+{
|
|
+ if (val < 0) {
|
|
+ return val;
|
|
+ } else {
|
|
+ return -val;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* add with carry 32-bit unsigned */
|
|
+uint32_t HELPER(addc_u32)(uint32_t cc, uint32_t v1, uint32_t v2)
|
|
+{
|
|
+ uint32_t res;
|
|
+
|
|
+ res = v1 + v2;
|
|
+ if (cc & 2) {
|
|
+ res++;
|
|
+ }
|
|
+
|
|
+ return res;
|
|
+}
|
|
+
|
|
+/* subtract unsigned v2 from v1 with borrow */
|
|
+uint32_t HELPER(slb)(uint32_t cc, uint32_t r1, uint32_t v2)
|
|
+{
|
|
+ uint32_t v1 = env->regs[r1];
|
|
+ uint32_t res = v1 + (~v2) + (cc >> 1);
|
|
+
|
|
+ env->regs[r1] = (env->regs[r1] & 0xffffffff00000000ULL) | res;
|
|
+ if (cc & 2) {
|
|
+ /* borrow */
|
|
+ return v1 ? 1 : 0;
|
|
+ } else {
|
|
+ return v1 ? 3 : 2;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* subtract unsigned v2 from v1 with borrow */
|
|
+uint32_t HELPER(slbg)(uint32_t cc, uint32_t r1, uint64_t v1, uint64_t v2)
|
|
+{
|
|
+ uint64_t res = v1 + (~v2) + (cc >> 1);
|
|
+
|
|
+ env->regs[r1] = res;
|
|
+ if (cc & 2) {
|
|
+ /* borrow */
|
|
+ return v1 ? 1 : 0;
|
|
+ } else {
|
|
+ return v1 ? 3 : 2;
|
|
+ }
|
|
+}
|
|
+
|
|
+/* find leftmost one */
|
|
+uint32_t HELPER(flogr)(uint32_t r1, uint64_t v2)
|
|
+{
|
|
+ uint64_t res = 0;
|
|
+ uint64_t ov2 = v2;
|
|
+
|
|
+ while (!(v2 & 0x8000000000000000ULL) && v2) {
|
|
+ v2 <<= 1;
|
|
+ res++;
|
|
+ }
|
|
+
|
|
+ if (!v2) {
|
|
+ env->regs[r1] = 64;
|
|
+ env->regs[r1 + 1] = 0;
|
|
+ return 0;
|
|
+ } else {
|
|
+ env->regs[r1] = res;
|
|
+ env->regs[r1 + 1] = ov2 & ~(0x8000000000000000ULL >> res);
|
|
+ return 2;
|
|
+ }
|
|
+}
|
|
+
|
|
+uint64_t HELPER(cvd)(int32_t bin)
|
|
+{
|
|
+ /* positive 0 */
|
|
+ uint64_t dec = 0x0c;
|
|
+ int shift = 4;
|
|
+
|
|
+ if (bin < 0) {
|
|
+ bin = -bin;
|
|
+ dec = 0x0d;
|
|
+ }
|
|
+
|
|
+ for (shift = 4; (shift < 64) && bin; shift += 4) {
|
|
+ int current_number = bin % 10;
|
|
+
|
|
+ dec |= (current_number) << shift;
|
|
+ bin /= 10;
|
|
+ }
|
|
+
|
|
+ return dec;
|
|
+}
|
|
diff --git a/target-s390x/op_helper.c b/target-s390x/op_helper.c
|
|
index eced890..3b8b997 100644
|
|
--- a/target-s390x/op_helper.c
|
|
+++ b/target-s390x/op_helper.c
|
|
@@ -352,49 +352,6 @@ void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)
|
|
HELPER_LOG("\n");
|
|
}
|
|
|
|
-/* 64/64 -> 128 unsigned multiplication */
|
|
-void HELPER(mlg)(uint32_t r1, uint64_t v2)
|
|
-{
|
|
-#if HOST_LONG_BITS == 64 && defined(__GNUC__)
|
|
- /* assuming 64-bit hosts have __uint128_t */
|
|
- __uint128_t res = (__uint128_t)env->regs[r1 + 1];
|
|
-
|
|
- res *= (__uint128_t)v2;
|
|
- env->regs[r1] = (uint64_t)(res >> 64);
|
|
- env->regs[r1 + 1] = (uint64_t)res;
|
|
-#else
|
|
- mulu64(&env->regs[r1 + 1], &env->regs[r1], env->regs[r1 + 1], v2);
|
|
-#endif
|
|
-}
|
|
-
|
|
-/* 128 -> 64/64 unsigned division */
|
|
-void HELPER(dlg)(uint32_t r1, uint64_t v2)
|
|
-{
|
|
- uint64_t divisor = v2;
|
|
-
|
|
- if (!env->regs[r1]) {
|
|
- /* 64 -> 64/64 case */
|
|
- env->regs[r1] = env->regs[r1 + 1] % divisor;
|
|
- env->regs[r1 + 1] = env->regs[r1 + 1] / divisor;
|
|
- return;
|
|
- } else {
|
|
-#if HOST_LONG_BITS == 64 && defined(__GNUC__)
|
|
- /* assuming 64-bit hosts have __uint128_t */
|
|
- __uint128_t dividend = (((__uint128_t)env->regs[r1]) << 64) |
|
|
- (env->regs[r1 + 1]);
|
|
- __uint128_t quotient = dividend / divisor;
|
|
- __uint128_t remainder = dividend % divisor;
|
|
-
|
|
- env->regs[r1 + 1] = quotient;
|
|
- env->regs[r1] = remainder;
|
|
-#else
|
|
- /* 32-bit hosts would need special wrapper functionality - just abort if
|
|
- we encounter such a case; it's very unlikely anyways. */
|
|
- cpu_abort(env, "128 -> 64/64 division not implemented\n");
|
|
-#endif
|
|
- }
|
|
-}
|
|
-
|
|
static inline uint64_t get_address(int x2, int b2, int d2)
|
|
{
|
|
uint64_t r = d2;
|
|
@@ -677,61 +634,6 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)
|
|
return cc;
|
|
}
|
|
|
|
-/* absolute value 32-bit */
|
|
-uint32_t HELPER(abs_i32)(int32_t val)
|
|
-{
|
|
- if (val < 0) {
|
|
- return -val;
|
|
- } else {
|
|
- return val;
|
|
- }
|
|
-}
|
|
-
|
|
-/* negative absolute value 32-bit */
|
|
-int32_t HELPER(nabs_i32)(int32_t val)
|
|
-{
|
|
- if (val < 0) {
|
|
- return val;
|
|
- } else {
|
|
- return -val;
|
|
- }
|
|
-}
|
|
-
|
|
-/* absolute value 64-bit */
|
|
-uint64_t HELPER(abs_i64)(int64_t val)
|
|
-{
|
|
- HELPER_LOG("%s: val 0x%" PRIx64 "\n", __func__, val);
|
|
-
|
|
- if (val < 0) {
|
|
- return -val;
|
|
- } else {
|
|
- return val;
|
|
- }
|
|
-}
|
|
-
|
|
-/* negative absolute value 64-bit */
|
|
-int64_t HELPER(nabs_i64)(int64_t val)
|
|
-{
|
|
- if (val < 0) {
|
|
- return val;
|
|
- } else {
|
|
- return -val;
|
|
- }
|
|
-}
|
|
-
|
|
-/* add with carry 32-bit unsigned */
|
|
-uint32_t HELPER(addc_u32)(uint32_t cc, uint32_t v1, uint32_t v2)
|
|
-{
|
|
- uint32_t res;
|
|
-
|
|
- res = v1 + v2;
|
|
- if (cc & 2) {
|
|
- res++;
|
|
- }
|
|
-
|
|
- return res;
|
|
-}
|
|
-
|
|
/* store character under mask high operates on the upper half of r1 */
|
|
void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)
|
|
{
|
|
@@ -936,57 +838,6 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
return cc;
|
|
}
|
|
|
|
-/* subtract unsigned v2 from v1 with borrow */
|
|
-uint32_t HELPER(slb)(uint32_t cc, uint32_t r1, uint32_t v2)
|
|
-{
|
|
- uint32_t v1 = env->regs[r1];
|
|
- uint32_t res = v1 + (~v2) + (cc >> 1);
|
|
-
|
|
- env->regs[r1] = (env->regs[r1] & 0xffffffff00000000ULL) | res;
|
|
- if (cc & 2) {
|
|
- /* borrow */
|
|
- return v1 ? 1 : 0;
|
|
- } else {
|
|
- return v1 ? 3 : 2;
|
|
- }
|
|
-}
|
|
-
|
|
-/* subtract unsigned v2 from v1 with borrow */
|
|
-uint32_t HELPER(slbg)(uint32_t cc, uint32_t r1, uint64_t v1, uint64_t v2)
|
|
-{
|
|
- uint64_t res = v1 + (~v2) + (cc >> 1);
|
|
-
|
|
- env->regs[r1] = res;
|
|
- if (cc & 2) {
|
|
- /* borrow */
|
|
- return v1 ? 1 : 0;
|
|
- } else {
|
|
- return v1 ? 3 : 2;
|
|
- }
|
|
-}
|
|
-
|
|
-/* find leftmost one */
|
|
-uint32_t HELPER(flogr)(uint32_t r1, uint64_t v2)
|
|
-{
|
|
- uint64_t res = 0;
|
|
- uint64_t ov2 = v2;
|
|
-
|
|
- while (!(v2 & 0x8000000000000000ULL) && v2) {
|
|
- v2 <<= 1;
|
|
- res++;
|
|
- }
|
|
-
|
|
- if (!v2) {
|
|
- env->regs[r1] = 64;
|
|
- env->regs[r1 + 1] = 0;
|
|
- return 0;
|
|
- } else {
|
|
- env->regs[r1] = res;
|
|
- env->regs[r1 + 1] = ov2 & ~(0x8000000000000000ULL >> res);
|
|
- return 2;
|
|
- }
|
|
-}
|
|
-
|
|
/* checksum */
|
|
void HELPER(cksm)(uint32_t r1, uint32_t r2)
|
|
{
|
|
@@ -1026,27 +877,6 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
|
|
((uint32_t)cksm + (cksm >> 32));
|
|
}
|
|
|
|
-uint64_t HELPER(cvd)(int32_t bin)
|
|
-{
|
|
- /* positive 0 */
|
|
- uint64_t dec = 0x0c;
|
|
- int shift = 4;
|
|
-
|
|
- if (bin < 0) {
|
|
- bin = -bin;
|
|
- dec = 0x0d;
|
|
- }
|
|
-
|
|
- for (shift = 4; (shift < 64) && bin; shift += 4) {
|
|
- int current_number = bin % 10;
|
|
-
|
|
- dec |= (current_number) << shift;
|
|
- bin /= 10;
|
|
- }
|
|
-
|
|
- return dec;
|
|
-}
|
|
-
|
|
void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
|
|
{
|
|
int len_dest = len >> 4;
|
|
--
|
|
1.8.0.2
|
|
|