The following changes since commit 3214bec13d8d4c40f707d21d8350d04e4123ae97:

Merge tag 'migration-20250110-pull-request' of https://gitlab.com/farosas/qemu into staging (2025-01-10 13:39:19 -0500)

https://git.linaro.org/people/pmaydell/qemu-arm.git tags/pull-target-arm-20250113

for you to fetch changes up to 435d260e7ec5ff9c79e3e62f1d66ec82d2d691ae:

docs/system/arm/virt: mention specific migration information (2025-01-13 12:35:35 +0000)

* hw/arm_sysctl: fix extracting 31th bit of val

* hw/misc: cast rpm to uint64_t

* tests/qtest/boot-serial-test: Improve ASM

* target/arm: Move minor arithmetic helpers out of helper.c

* target/arm: change default pauth algorithm to impdef

Anastasia Belova (1):

hw/arm_sysctl: fix extracting 31th bit of val

target/arm: Move minor arithmetic helpers out of helper.c

tests/tcg/aarch64: force qarma5 for pauth-3 test

Philippe Mathieu-Daudé (4):

tests/qtest/boot-serial-test: Improve ASM comments of PL011 tests

tests/qtest/boot-serial-test: Reduce for() loop in PL011 tests

tests/qtest/boot-serial-test: Reorder pair of instructions in PL011 test

tests/qtest/boot-serial-test: Initialize PL011 Control register

Pierrick Bouvier (3):

target/arm: add new property to select pauth-qarma5

target/arm: change default pauth algorithm to impdef

docs/system/arm/virt: mention specific migration information

Tigran Sogomonian (1):

hw/misc: cast rpm to uint64_t

docs/system/arm/cpu-features.rst | 7 +-

docs/system/arm/virt.rst | 4 +

docs/system/introduction.rst | 2 +-

target/arm/cpu.h | 4 +

hw/core/machine.c | 4 +-

hw/misc/arm_sysctl.c | 2 +-

hw/misc/npcm7xx_mft.c | 5 +-

target/arm/arm-qmp-cmds.c | 2 +-

target/arm/cpu.c | 2 +

target/arm/cpu64.c | 38 ++-

target/arm/helper.c | 285 -----------------------

target/arm/tcg/arith_helper.c | 296 ++++++++++++++++++++++++

tests/qtest/arm-cpu-features.c | 15 +-

tests/qtest/boot-serial-test.c | 23 +-

target/arm/{op_addsub.h => tcg/op_addsub.c.inc} | 0

target/arm/tcg/meson.build | 1 +

tests/tcg/aarch64/Makefile.softmmu-target | 3 +

17 files changed, 377 insertions(+), 316 deletions(-)

create mode 100644 target/arm/tcg/arith_helper.c

rename target/arm/{op_addsub.h => tcg/op_addsub.c.inc} (100%)

From: Anastasia Belova <abelova@astralinux.ru>

1 << 31 is casted to uint64_t while bitwise and with val.

So this value may become 0xffffffff80000000 but only

31th "start" bit is required.

This is not possible in practice because the MemoryRegionOps

uses the default max access size of 4 bytes and so none

of the upper bytes of val will be set, but the bitfield

extract API is clearer anyway.

Use the bitfield extract() API instead.

Found by Linux Verification Center (linuxtesting.org) with SVACE.

Signed-off-by: Anastasia Belova <abelova@astralinux.ru>

Message-id: 20241220125429.7552-1-abelova@astralinux.ru

Reviewed-by: Peter Maydell <peter.maydell@linaro.org>

[PMM: add clarification to commit message]

hw/misc/arm_sysctl.c | 2 +-

diff --git a/hw/misc/arm_sysctl.c b/hw/misc/arm_sysctl.c

--- a/hw/misc/arm_sysctl.c

+++ b/hw/misc/arm_sysctl.c

@@ -XXX,XX +XXX,XX @@ static void arm_sysctl_write(void *opaque, hwaddr offset,

* as zero.

*/

s->sys_cfgctrl = val & ~((3 << 18) | (1 << 31));

- if (val & (1 << 31)) {

+ if (extract64(val, 31, 1)) {

/* Start bit set -- actually do something */

unsigned int dcc = extract32(s->sys_cfgctrl, 26, 4);

unsigned int function = extract32(s->sys_cfgctrl, 20, 6);

From: Tigran Sogomonian <tsogomonian@astralinux.ru>

The value of an arithmetic expression

'rpm * NPCM7XX_MFT_PULSE_PER_REVOLUTION' is a subject

to overflow because its operands are not cast to

a larger data type before performing arithmetic. Thus, need

to cast rpm to uint64_t.

Found by Linux Verification Center (linuxtesting.org) with SVACE.

Signed-off-by: Tigran Sogomonian <tsogomonian@astralinux.ru>

Reviewed-by: Patrick Leis <venture@google.com>

Reviewed-by: Hao Wu <wuhaotsh@google.com>

Message-id: 20241226130311.1349-1-tsogomonian@astralinux.ru

hw/misc/npcm7xx_mft.c | 5 +++--

1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/hw/misc/npcm7xx_mft.c b/hw/misc/npcm7xx_mft.c

--- a/hw/misc/npcm7xx_mft.c

+++ b/hw/misc/npcm7xx_mft.c

@@ -XXX,XX +XXX,XX @@ static NPCM7xxMFTCaptureState npcm7xx_mft_compute_cnt(

* RPM = revolution/min. The time for one revlution (in ns) is

* MINUTE_TO_NANOSECOND / RPM.

*/

- count = clock_ns_to_ticks(clock, (60 * NANOSECONDS_PER_SECOND) /

- (rpm * NPCM7XX_MFT_PULSE_PER_REVOLUTION));

+ count = clock_ns_to_ticks(clock,

+ (uint64_t)(60 * NANOSECONDS_PER_SECOND) /

+ ((uint64_t)rpm * NPCM7XX_MFT_PULSE_PER_REVOLUTION));

if (count > NPCM7XX_MFT_MAX_CNT) {

From: Philippe Mathieu-Daudé <philmd@linaro.org>

Re-indent ASM comments adding the 'loop:' label.

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Reviewed-by: Fabiano Rosas <farosas@suse.de>

tests/qtest/boot-serial-test.c | 18 +++++++++---------

1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/tests/qtest/boot-serial-test.c b/tests/qtest/boot-serial-test.c

--- a/tests/qtest/boot-serial-test.c

+++ b/tests/qtest/boot-serial-test.c

@@ -XXX,XX +XXX,XX @@ static const uint8_t kernel_plml605[] = {

};

static const uint8_t bios_raspi2[] = {

- 0x08, 0x30, 0x9f, 0xe5, /* ldr r3,[pc,#8] Get base */

- 0x54, 0x20, 0xa0, 0xe3, /* mov r2,#'T' */

- 0x00, 0x20, 0xc3, 0xe5, /* strb r2,[r3] */

- 0xfb, 0xff, 0xff, 0xea, /* b loop */

- 0x00, 0x10, 0x20, 0x3f, /* 0x3f201000 = UART0 base addr */

+ 0x08, 0x30, 0x9f, 0xe5, /* loop: ldr r3, [pc, #8] Get &UART0 */

+ 0x54, 0x20, 0xa0, 0xe3, /* mov r2, #'T' */

+ 0x00, 0x20, 0xc3, 0xe5, /* strb r2, [r3] *TXDAT = 'T' */

+ 0xfb, 0xff, 0xff, 0xea, /* b -12 (loop) */

+ 0x00, 0x10, 0x20, 0x3f, /* UART0: 0x3f201000 */

};

static const uint8_t kernel_aarch64[] = {

- 0x81, 0x0a, 0x80, 0x52, /* mov w1, #0x54 */

- 0x02, 0x20, 0xa1, 0xd2, /* mov x2, #0x9000000 */

- 0x41, 0x00, 0x00, 0x39, /* strb w1, [x2] */

- 0xfd, 0xff, 0xff, 0x17, /* b -12 (loop) */

+ 0x81, 0x0a, 0x80, 0x52, /* loop: mov w1, #'T' */

+ 0x02, 0x20, 0xa1, 0xd2, /* mov x2, #0x9000000 Load UART0 */

+ 0x41, 0x00, 0x00, 0x39, /* strb w1, [x2] *TXDAT = 'T' */

+ 0xfd, 0xff, 0xff, 0x17, /* b -12 (loop) */

};

static const uint8_t kernel_nrf51[] = {

From: Philippe Mathieu-Daudé <philmd@linaro.org>

Since registers are not modified, we don't need

to refill their values. Directly jump to the previous

store instruction to keep filling the TXDAT register.

The equivalent C code remains:

while (true) {

*UART_DATA = 'T';

}

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Reviewed-by: Fabiano Rosas <farosas@suse.de>

tests/qtest/boot-serial-test.c | 12 ++++++------

1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/qtest/boot-serial-test.c b/tests/qtest/boot-serial-test.c

--- a/tests/qtest/boot-serial-test.c

+++ b/tests/qtest/boot-serial-test.c

@@ -XXX,XX +XXX,XX @@ static const uint8_t kernel_plml605[] = {

};

static const uint8_t bios_raspi2[] = {

- 0x08, 0x30, 0x9f, 0xe5, /* loop: ldr r3, [pc, #8] Get &UART0 */

+ 0x08, 0x30, 0x9f, 0xe5, /* ldr r3, [pc, #8] Get &UART0 */

0x54, 0x20, 0xa0, 0xe3, /* mov r2, #'T' */

- 0x00, 0x20, 0xc3, 0xe5, /* strb r2, [r3] *TXDAT = 'T' */

- 0xfb, 0xff, 0xff, 0xea, /* b -12 (loop) */

+ 0x00, 0x20, 0xc3, 0xe5, /* loop: strb r2, [r3] *TXDAT = 'T' */

+ 0xff, 0xff, 0xff, 0xea, /* b -4 (loop) */

0x00, 0x10, 0x20, 0x3f, /* UART0: 0x3f201000 */

};

static const uint8_t kernel_aarch64[] = {

- 0x81, 0x0a, 0x80, 0x52, /* loop: mov w1, #'T' */

+ 0x81, 0x0a, 0x80, 0x52, /* mov w1, #'T' */

0x02, 0x20, 0xa1, 0xd2, /* mov x2, #0x9000000 Load UART0 */

- 0x41, 0x00, 0x00, 0x39, /* strb w1, [x2] *TXDAT = 'T' */

- 0xfd, 0xff, 0xff, 0x17, /* b -12 (loop) */

+ 0x41, 0x00, 0x00, 0x39, /* loop: strb w1, [x2] *TXDAT = 'T' */

+ 0xff, 0xff, 0xff, 0x17, /* b -4 (loop) */

};

static const uint8_t kernel_nrf51[] = {

From: Philippe Mathieu-Daudé <philmd@linaro.org>

In the next commit we are going to use a different value

for the $w1 register, maintaining the same $x2 value. In

order to keep the next commit trivial to review, set $x2

before $w1.

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Reviewed-by: Fabiano Rosas <farosas@suse.de>

tests/qtest/boot-serial-test.c | 2 +-

diff --git a/tests/qtest/boot-serial-test.c b/tests/qtest/boot-serial-test.c

--- a/tests/qtest/boot-serial-test.c

+++ b/tests/qtest/boot-serial-test.c

@@ -XXX,XX +XXX,XX @@ static const uint8_t bios_raspi2[] = {

};

static const uint8_t kernel_aarch64[] = {

- 0x81, 0x0a, 0x80, 0x52, /* mov w1, #'T' */

0x02, 0x20, 0xa1, 0xd2, /* mov x2, #0x9000000 Load UART0 */

+ 0x81, 0x0a, 0x80, 0x52, /* mov w1, #'T' */

0x41, 0x00, 0x00, 0x39, /* loop: strb w1, [x2] *TXDAT = 'T' */

0xff, 0xff, 0xff, 0x17, /* b -4 (loop) */

};

From: Philippe Mathieu-Daudé <philmd@linaro.org>

The tests using the PL011 UART of the virt and raspi machines

weren't properly enabling the UART and its transmitter previous

to sending characters. Follow the PL011 manual initialization

recommendation by setting the proper bits of the control register.

Update the ASM code prefixing:

*UART_CTRL = UART_ENABLE | TX_ENABLE;

to:

while (true) {

*UART_DATA = 'T';

}

Note, since commit 51b61dd4d56 ("hw/char/pl011: Warn when using

disabled transmitter") incomplete PL011 initialization can be

logged using the '-d guest_errors' command line option.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>

tests/qtest/boot-serial-test.c | 7 ++++++-

1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/qtest/boot-serial-test.c b/tests/qtest/boot-serial-test.c

--- a/tests/qtest/boot-serial-test.c

+++ b/tests/qtest/boot-serial-test.c

@@ -XXX,XX +XXX,XX @@ static const uint8_t kernel_plml605[] = {

};

static const uint8_t bios_raspi2[] = {

- 0x08, 0x30, 0x9f, 0xe5, /* ldr r3, [pc, #8] Get &UART0 */

+ 0x10, 0x30, 0x9f, 0xe5, /* ldr r3, [pc, #16] Get &UART0 */

+ 0x10, 0x20, 0x9f, 0xe5, /* ldr r2, [pc, #16] Get &CR */

+ 0xb0, 0x23, 0xc3, 0xe1, /* strh r2, [r3, #48] Set CR */

0x54, 0x20, 0xa0, 0xe3, /* mov r2, #'T' */

0x00, 0x20, 0xc3, 0xe5, /* loop: strb r2, [r3] *TXDAT = 'T' */

0xff, 0xff, 0xff, 0xea, /* b -4 (loop) */

0x00, 0x10, 0x20, 0x3f, /* UART0: 0x3f201000 */

+ 0x01, 0x01, 0x00, 0x00, /* CR: 0x101 = UARTEN|TXE */

};

static const uint8_t kernel_aarch64[] = {

0x02, 0x20, 0xa1, 0xd2, /* mov x2, #0x9000000 Load UART0 */

+ 0x21, 0x20, 0x80, 0x52, /* mov w1, 0x101 CR = UARTEN|TXE */

+ 0x41, 0x60, 0x00, 0x79, /* strh w1, [x2, #48] Set CR */

0x81, 0x0a, 0x80, 0x52, /* mov w1, #'T' */

0x41, 0x00, 0x00, 0x39, /* loop: strb w1, [x2] *TXDAT = 'T' */

0xff, 0xff, 0xff, 0x17, /* b -4 (loop) */

helper.c includes some small TCG helper functions used for mostly

arithmetic instructions. These are TCG only and there's no need for

them to be in the large and unwieldy helper.c. Move them out to

their own source file in the tcg/ subdirectory, together with the

op_addsub.h multiply-included template header that they use.

Since we are moving op_addsub.h, we take the opportunity to

give it a name which matches our convention for files which

are not true header files but which are #included from other

C files: op_addsub.c.inc.

(Ironically, this means that helper.c no longer contains

any TCG helper function definitions at all.)

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Message-id: 20250110131211.2546314-1-peter.maydell@linaro.org

target/arm/helper.c | 285 -----------------

target/arm/tcg/arith_helper.c | 296 ++++++++++++++++++

.../arm/{op_addsub.h => tcg/op_addsub.c.inc} | 0

target/arm/tcg/meson.build | 1 +

4 files changed, 297 insertions(+), 285 deletions(-)

create mode 100644 target/arm/tcg/arith_helper.c

rename target/arm/{op_addsub.h => tcg/op_addsub.c.inc} (100%)

diff --git a/target/arm/helper.c b/target/arm/helper.c

index XXXXXXX..XXXXXXX 100644

--- a/target/arm/helper.c

+++ b/target/arm/helper.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/main-loop.h"

#include "qemu/timer.h"

#include "qemu/bitops.h"

-#include "qemu/crc32c.h"

#include "qemu/qemu-print.h"

#include "exec/exec-all.h"

#include "exec/translation-block.h"

-#include <zlib.h> /* for crc32 */

#include "hw/irq.h"

#include "system/cpu-timers.h"

#include "system/kvm.h"

@@ -XXX,XX +XXX,XX @@ ARMVAParameters aa64_va_parameters(CPUARMState *env, uint64_t va,

};

}

-/*

- * Note that signed overflow is undefined in C. The following routines are

- * careful to use unsigned types where modulo arithmetic is required.

- * Failure to do so _will_ break on newer gcc.

- */

-

-/* Signed saturating arithmetic. */

-

-/* Perform 16-bit signed saturating addition. */

-static inline uint16_t add16_sat(uint16_t a, uint16_t b)

-{

- uint16_t res;

-

- res = a + b;

- if (((res ^ a) & 0x8000) && !((a ^ b) & 0x8000)) {

- if (a & 0x8000) {

- res = 0x8000;

- } else {

- res = 0x7fff;

- }

- }

- return res;

-}

-

-/* Perform 8-bit signed saturating addition. */

-static inline uint8_t add8_sat(uint8_t a, uint8_t b)

-{

- uint8_t res;

-

- res = a + b;

- if (((res ^ a) & 0x80) && !((a ^ b) & 0x80)) {

- if (a & 0x80) {

- res = 0x80;

- } else {

- res = 0x7f;

- }

- }

- return res;

-}

-

-/* Perform 16-bit signed saturating subtraction. */

-static inline uint16_t sub16_sat(uint16_t a, uint16_t b)

-{

- uint16_t res;

-

- res = a - b;

- if (((res ^ a) & 0x8000) && ((a ^ b) & 0x8000)) {

- if (a & 0x8000) {

- res = 0x8000;

- } else {

- res = 0x7fff;

- }

- }

- return res;

-}

-

-/* Perform 8-bit signed saturating subtraction. */

-static inline uint8_t sub8_sat(uint8_t a, uint8_t b)

-{

- uint8_t res;

-

- res = a - b;

- if (((res ^ a) & 0x80) && ((a ^ b) & 0x80)) {

- if (a & 0x80) {

- res = 0x80;

- } else {

- res = 0x7f;

- }

- }

- return res;

-}

-

-#define ADD16(a, b, n) RESULT(add16_sat(a, b), n, 16);

-#define SUB16(a, b, n) RESULT(sub16_sat(a, b), n, 16);

-#define ADD8(a, b, n) RESULT(add8_sat(a, b), n, 8);

-#define SUB8(a, b, n) RESULT(sub8_sat(a, b), n, 8);

-#define PFX q

-

-#include "op_addsub.h"

-

-/* Unsigned saturating arithmetic. */

-static inline uint16_t add16_usat(uint16_t a, uint16_t b)

-{

- uint16_t res;

- res = a + b;

- if (res < a) {

- res = 0xffff;

- }

- return res;

-}

-

-static inline uint16_t sub16_usat(uint16_t a, uint16_t b)

-{

- if (a > b) {

- return a - b;

- } else {

- return 0;

- }

-}

-

-static inline uint8_t add8_usat(uint8_t a, uint8_t b)

-{

- uint8_t res;

- res = a + b;

- if (res < a) {

- res = 0xff;

- }

- return res;

-}

-

-static inline uint8_t sub8_usat(uint8_t a, uint8_t b)

-{

- if (a > b) {

- return a - b;

- } else {

- return 0;

- }

-}

-

-#define ADD16(a, b, n) RESULT(add16_usat(a, b), n, 16);

-#define SUB16(a, b, n) RESULT(sub16_usat(a, b), n, 16);

-#define ADD8(a, b, n) RESULT(add8_usat(a, b), n, 8);

-#define SUB8(a, b, n) RESULT(sub8_usat(a, b), n, 8);

-#define PFX uq

-

-#include "op_addsub.h"

-

-/* Signed modulo arithmetic. */

-#define SARITH16(a, b, n, op) do { \

- int32_t sum; \

- sum = (int32_t)(int16_t)(a) op (int32_t)(int16_t)(b); \

- RESULT(sum, n, 16); \

- if (sum >= 0) \

- ge |= 3 << (n * 2); \

- } while (0)

-

-#define SARITH8(a, b, n, op) do { \

- int32_t sum; \

- sum = (int32_t)(int8_t)(a) op (int32_t)(int8_t)(b); \

- RESULT(sum, n, 8); \

- if (sum >= 0) \

- ge |= 1 << n; \

- } while (0)

-

-

-#define ADD16(a, b, n) SARITH16(a, b, n, +)

-#define SUB16(a, b, n) SARITH16(a, b, n, -)

-#define ADD8(a, b, n) SARITH8(a, b, n, +)

-#define SUB8(a, b, n) SARITH8(a, b, n, -)

-#define PFX s

-#define ARITH_GE

-

-#include "op_addsub.h"

-

-/* Unsigned modulo arithmetic. */

-#define ADD16(a, b, n) do { \

- uint32_t sum; \

- sum = (uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b); \

- RESULT(sum, n, 16); \

- if ((sum >> 16) == 1) \

- ge |= 3 << (n * 2); \

- } while (0)

-

-#define ADD8(a, b, n) do { \

- uint32_t sum; \

- sum = (uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b); \

- RESULT(sum, n, 8); \

- if ((sum >> 8) == 1) \

- ge |= 1 << n; \

- } while (0)

-

-#define SUB16(a, b, n) do { \

- uint32_t sum; \

- sum = (uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b); \

- RESULT(sum, n, 16); \

- if ((sum >> 16) == 0) \

- ge |= 3 << (n * 2); \

- } while (0)

-

-#define SUB8(a, b, n) do { \

- uint32_t sum; \

- sum = (uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b); \

- RESULT(sum, n, 8); \

- if ((sum >> 8) == 0) \

- ge |= 1 << n; \

- } while (0)

-

-#define PFX u

-#define ARITH_GE

-

-#include "op_addsub.h"

-

-/* Halved signed arithmetic. */

-#define ADD16(a, b, n) \

- RESULT(((int32_t)(int16_t)(a) + (int32_t)(int16_t)(b)) >> 1, n, 16)

-#define SUB16(a, b, n) \

- RESULT(((int32_t)(int16_t)(a) - (int32_t)(int16_t)(b)) >> 1, n, 16)

-#define ADD8(a, b, n) \

- RESULT(((int32_t)(int8_t)(a) + (int32_t)(int8_t)(b)) >> 1, n, 8)

-#define SUB8(a, b, n) \

- RESULT(((int32_t)(int8_t)(a) - (int32_t)(int8_t)(b)) >> 1, n, 8)

-#define PFX sh

-

-#include "op_addsub.h"

-

-/* Halved unsigned arithmetic. */

-#define ADD16(a, b, n) \

- RESULT(((uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b)) >> 1, n, 16)

-#define SUB16(a, b, n) \

- RESULT(((uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b)) >> 1, n, 16)

-#define ADD8(a, b, n) \

- RESULT(((uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b)) >> 1, n, 8)

-#define SUB8(a, b, n) \

- RESULT(((uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b)) >> 1, n, 8)

-#define PFX uh

-

-#include "op_addsub.h"

-

-static inline uint8_t do_usad(uint8_t a, uint8_t b)

-{

- if (a > b) {

- return a - b;

- } else {

- return b - a;

- }

-}

-

-/* Unsigned sum of absolute byte differences. */

-uint32_t HELPER(usad8)(uint32_t a, uint32_t b)

-{

- uint32_t sum;

- sum = do_usad(a, b);

- sum += do_usad(a >> 8, b >> 8);

- sum += do_usad(a >> 16, b >> 16);

- sum += do_usad(a >> 24, b >> 24);

- return sum;

-}

-

-/* For ARMv6 SEL instruction. */

-uint32_t HELPER(sel_flags)(uint32_t flags, uint32_t a, uint32_t b)

-{

- uint32_t mask;

-

- mask = 0;

- if (flags & 1) {

- mask |= 0xff;

- }

- if (flags & 2) {

- mask |= 0xff00;

- }

- if (flags & 4) {

- mask |= 0xff0000;

- }

- if (flags & 8) {

- mask |= 0xff000000;

- }

- return (a & mask) | (b & ~mask);

-}

-

-/*

- * CRC helpers.

- * The upper bytes of val (above the number specified by 'bytes') must have

- * been zeroed out by the caller.

- */

-uint32_t HELPER(crc32)(uint32_t acc, uint32_t val, uint32_t bytes)

-{

- uint8_t buf[4];

-

- stl_le_p(buf, val);

-

- /* zlib crc32 converts the accumulator and output to one's complement. */

- return crc32(acc ^ 0xffffffff, buf, bytes) ^ 0xffffffff;

-}

-

-uint32_t HELPER(crc32c)(uint32_t acc, uint32_t val, uint32_t bytes)

-{

- uint8_t buf[4];

-

- stl_le_p(buf, val);

-

- /* Linux crc32c converts the output to one's complement. */

- return crc32c(acc, buf, bytes) ^ 0xffffffff;

-}

/*

* Return the exception level to which FP-disabled exceptions should

diff --git a/target/arm/tcg/arith_helper.c b/target/arm/tcg/arith_helper.c

+++ b/target/arm/tcg/arith_helper.c

+ * ARM generic helpers for various arithmetical operations.

+ *

+ * This code is licensed under the GNU GPL v2 or later.

+ *

+#include "qemu/osdep.h"

+#include "cpu.h"

+#include "exec/helper-proto.h"

+#include "qemu/crc32c.h"

+#include <zlib.h> /* for crc32 */

+

+/*

+ * Note that signed overflow is undefined in C. The following routines are

+ * careful to use unsigned types where modulo arithmetic is required.

+ * Failure to do so _will_ break on newer gcc.

+ */

+

+/* Signed saturating arithmetic. */

+

+/* Perform 16-bit signed saturating addition. */

+static inline uint16_t add16_sat(uint16_t a, uint16_t b)

+{

+ uint16_t res;

+

+ res = a + b;

+ if (((res ^ a) & 0x8000) && !((a ^ b) & 0x8000)) {

+ if (a & 0x8000) {

+ res = 0x8000;

+ } else {

+ res = 0x7fff;

+ return res;

+}

+

+/* Perform 8-bit signed saturating addition. */

+static inline uint8_t add8_sat(uint8_t a, uint8_t b)

+{

+ uint8_t res;

+

+ res = a + b;

+ if (((res ^ a) & 0x80) && !((a ^ b) & 0x80)) {

+ if (a & 0x80) {

+ res = 0x80;

+ } else {

+ res = 0x7f;

+ }

+ }

+ return res;

+}

+

+/* Perform 16-bit signed saturating subtraction. */

+static inline uint16_t sub16_sat(uint16_t a, uint16_t b)

+{

+ uint16_t res;

+

+ res = a - b;

+ if (((res ^ a) & 0x8000) && ((a ^ b) & 0x8000)) {

+ if (a & 0x8000) {

+ res = 0x8000;

+ } else {

+ res = 0x7fff;

+ }

+ }

+ return res;

+}

+

+/* Perform 8-bit signed saturating subtraction. */

+static inline uint8_t sub8_sat(uint8_t a, uint8_t b)

+{

+ uint8_t res;

+

+ res = a - b;

+ if (((res ^ a) & 0x80) && ((a ^ b) & 0x80)) {

+ if (a & 0x80) {

+ res = 0x80;

+ } else {

+ res = 0x7f;

+ }

+ }

+ return res;

+}

+

+#define ADD16(a, b, n) RESULT(add16_sat(a, b), n, 16);

+#define SUB16(a, b, n) RESULT(sub16_sat(a, b), n, 16);

+#define ADD8(a, b, n) RESULT(add8_sat(a, b), n, 8);

+#define SUB8(a, b, n) RESULT(sub8_sat(a, b), n, 8);

+#define PFX q

+

+#include "op_addsub.c.inc"

+

+/* Unsigned saturating arithmetic. */

+static inline uint16_t add16_usat(uint16_t a, uint16_t b)

+{

+ uint16_t res;

+ res = a + b;

+ if (res < a) {

+ res = 0xffff;

+ }

+ return res;

+}

+

+static inline uint16_t sub16_usat(uint16_t a, uint16_t b)

+{

+ if (a > b) {

+ return a - b;

+ } else {

+ return 0;

+ }

+}

+

+static inline uint8_t add8_usat(uint8_t a, uint8_t b)

+{

+ uint8_t res;

+ res = a + b;

+ if (res < a) {

+ res = 0xff;

+ }

+ return res;

+}

+

+static inline uint8_t sub8_usat(uint8_t a, uint8_t b)

+{

+ if (a > b) {

+ return a - b;

+ } else {

+ return 0;

+ }

+}

+

+#define ADD16(a, b, n) RESULT(add16_usat(a, b), n, 16);

+#define SUB16(a, b, n) RESULT(sub16_usat(a, b), n, 16);

+#define ADD8(a, b, n) RESULT(add8_usat(a, b), n, 8);

+#define SUB8(a, b, n) RESULT(sub8_usat(a, b), n, 8);

+#define PFX uq

+

+#include "op_addsub.c.inc"

+

+/* Signed modulo arithmetic. */

+#define SARITH16(a, b, n, op) do { \

+ int32_t sum; \

+ sum = (int32_t)(int16_t)(a) op (int32_t)(int16_t)(b); \

+ RESULT(sum, n, 16); \

+ if (sum >= 0) \

+ ge |= 3 << (n * 2); \

+ } while (0)

+

+#define SARITH8(a, b, n, op) do { \

+ int32_t sum; \

+ sum = (int32_t)(int8_t)(a) op (int32_t)(int8_t)(b); \

+ RESULT(sum, n, 8); \

+ if (sum >= 0) \

+ ge |= 1 << n; \

+ } while (0)

+

+

+#define ADD16(a, b, n) SARITH16(a, b, n, +)

+#define SUB16(a, b, n) SARITH16(a, b, n, -)

+#define ADD8(a, b, n) SARITH8(a, b, n, +)

+#define SUB8(a, b, n) SARITH8(a, b, n, -)

+#define PFX s

+#define ARITH_GE

+

+#include "op_addsub.c.inc"

+

+/* Unsigned modulo arithmetic. */

+#define ADD16(a, b, n) do { \

+ uint32_t sum; \

+ sum = (uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b); \

+ RESULT(sum, n, 16); \

+ if ((sum >> 16) == 1) \

+ ge |= 3 << (n * 2); \

+ } while (0)

+

+#define ADD8(a, b, n) do { \

+ uint32_t sum; \

+ sum = (uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b); \

+ RESULT(sum, n, 8); \

+ if ((sum >> 8) == 1) \

+ ge |= 1 << n; \

+ } while (0)

+

+#define SUB16(a, b, n) do { \

+ uint32_t sum; \

+ sum = (uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b); \

+ RESULT(sum, n, 16); \

+ if ((sum >> 16) == 0) \

+ ge |= 3 << (n * 2); \

+ } while (0)

+

+#define SUB8(a, b, n) do { \

+ uint32_t sum; \

+ sum = (uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b); \

+ RESULT(sum, n, 8); \

+ if ((sum >> 8) == 0) \

+ ge |= 1 << n; \

+ } while (0)

+

+#define PFX u

+#define ARITH_GE

+

+#include "op_addsub.c.inc"

+

+/* Halved signed arithmetic. */

+#define ADD16(a, b, n) \

+ RESULT(((int32_t)(int16_t)(a) + (int32_t)(int16_t)(b)) >> 1, n, 16)

+#define SUB16(a, b, n) \

+ RESULT(((int32_t)(int16_t)(a) - (int32_t)(int16_t)(b)) >> 1, n, 16)

+#define ADD8(a, b, n) \

+ RESULT(((int32_t)(int8_t)(a) + (int32_t)(int8_t)(b)) >> 1, n, 8)

+#define SUB8(a, b, n) \

+ RESULT(((int32_t)(int8_t)(a) - (int32_t)(int8_t)(b)) >> 1, n, 8)

+#define PFX sh

+

+#include "op_addsub.c.inc"

+

+/* Halved unsigned arithmetic. */

+#define ADD16(a, b, n) \

+ RESULT(((uint32_t)(uint16_t)(a) + (uint32_t)(uint16_t)(b)) >> 1, n, 16)

+#define SUB16(a, b, n) \

+ RESULT(((uint32_t)(uint16_t)(a) - (uint32_t)(uint16_t)(b)) >> 1, n, 16)

+#define ADD8(a, b, n) \

+ RESULT(((uint32_t)(uint8_t)(a) + (uint32_t)(uint8_t)(b)) >> 1, n, 8)

+#define SUB8(a, b, n) \

+ RESULT(((uint32_t)(uint8_t)(a) - (uint32_t)(uint8_t)(b)) >> 1, n, 8)

+#define PFX uh

+