new file mode 100644
@@ -0,0 +1,145 @@
+/*
+ * Copyright(c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef HEX_TEST_H
+#define HEX_TEST_H
+
+static inline void __check32(int line, uint32_t val, uint32_t expect)
+{
+ if (val != expect) {
+ printf("ERROR at line %d: 0x%08x != 0x%08x\n", line, val, expect);
+ err++;
+ }
+}
+
+#define check32(RES, EXP) __check32(__LINE__, RES, EXP)
+
+static inline void __check64(int line, uint64_t val, uint64_t expect)
+{
+ if (val != expect) {
+ printf("ERROR at line %d: 0x%016llx != 0x%016llx\n", line, val, expect);
+ err++;
+ }
+}
+
+#define check64(RES, EXP) __check64(__LINE__, RES, EXP)
+
+static inline void __chk_error(const char *filename, int line, int ret)
+{
+ if (ret < 0) {
+ printf("ERROR %s:%d - %d\n", filename, line, ret);
+ err++;
+ }
+}
+
+#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))
+
+static inline void __checkp(int line, void *p, void *expect)
+{
+ if (p != expect) {
+ printf("ERROR at line %d: 0x%p != 0x%p\n", line, p, expect);
+ err++;
+ }
+}
+
+#define checkp(RES, EXP) __checkp(__LINE__, RES, EXP)
+
+static inline void __check32_ne(int line, uint32_t val, uint32_t expect)
+{
+ if (val == expect) {
+ printf("ERROR at line %d: 0x%08x == 0x%08x\n", line, val, expect);
+ err++;
+ }
+}
+
+#define check32_ne(RES, EXP) __check32_ne(__LINE__, RES, EXP)
+
+static inline void __check64_ne(int line, uint64_t val, uint64_t expect)
+{
+ if (val == expect) {
+ printf("ERROR at line %d: 0x%016llx == 0x%016llx\n", line, val, expect);
+ err++;
+ }
+}
+
+#define check64_ne(RES, EXP) __check64_ne(__LINE__, RES, EXP)
+
+/* Define the bits in Hexagon USR register */
+#define USR_OVF_BIT 0 /* Sticky saturation overflow */
+#define USR_FPINVF_BIT 1 /* IEEE FP invalid sticky flag */
+#define USR_FPDBZF_BIT 2 /* IEEE FP divide-by-zero sticky flag */
+#define USR_FPOVFF_BIT 3 /* IEEE FP overflow sticky flag */
+#define USR_FPUNFF_BIT 4 /* IEEE FP underflow sticky flag */
+#define USR_FPINPF_BIT 5 /* IEEE FP inexact sticky flag */
+
+/* Corresponding values in USR */
+#define USR_CLEAR 0
+#define USR_OVF (1 << USR_OVF_BIT)
+#define USR_FPINVF (1 << USR_FPINVF_BIT)
+#define USR_FPDBZF (1 << USR_FPDBZF_BIT)
+#define USR_FPOVFF (1 << USR_FPOVFF_BIT)
+#define USR_FPUNFF (1 << USR_FPUNFF_BIT)
+#define USR_FPINPF (1 << USR_FPINPF_BIT)
+
+/* Clear bits 0-5 in USR */
+#define CLEAR_USRBITS \
+ "r2 = usr\n\t" \
+ "r2 = and(r2, #0xffffffc0)\n\t" \
+ "usr = r2\n\t"
+
+/* Clear bits 1-5 in USR */
+#define CLEAR_FPSTATUS \
+ "r2 = usr\n\t" \
+ "r2 = and(r2, #0xffffffc1)\n\t" \
+ "usr = r2\n\t"
+
+/* Some useful floating point values */
+const uint32_t SF_INF = 0x7f800000;
+const uint32_t SF_QNaN = 0x7fc00000;
+const uint32_t SF_QNaN_special = 0x7f800001;
+const uint32_t SF_SNaN = 0x7fb00000;
+const uint32_t SF_QNaN_neg = 0xffc00000;
+const uint32_t SF_SNaN_neg = 0xffb00000;
+const uint32_t SF_HEX_NaN = 0xffffffff;
+const uint32_t SF_zero = 0x00000000;
+const uint32_t SF_zero_neg = 0x80000000;
+const uint32_t SF_one = 0x3f800000;
+const uint32_t SF_one_recip = 0x3f7f0001; /* 0.9960... */
+const uint32_t SF_one_invsqrta = 0x3f7f0000; /* 0.99609375 */
+const uint32_t SF_two = 0x40000000;
+const uint32_t SF_four = 0x40800000;
+const uint32_t SF_small_neg = 0xab98fba8;
+const uint32_t SF_large_pos = 0x5afa572e;
+const uint32_t SF_any = 0x3f800000;
+const uint32_t SF_denorm = 0x00000001;
+const uint32_t SF_random = 0x346001d6;
+
+const uint64_t DF_QNaN = 0x7ff8000000000000ULL;
+const uint64_t DF_SNaN = 0x7ff7000000000000ULL;
+const uint64_t DF_QNaN_neg = 0xfff8000000000000ULL;
+const uint64_t DF_SNaN_neg = 0xfff7000000000000ULL;
+const uint64_t DF_HEX_NaN = 0xffffffffffffffffULL;
+const uint64_t DF_zero = 0x0000000000000000ULL;
+const uint64_t DF_zero_neg = 0x8000000000000000ULL;
+const uint64_t DF_any = 0x3f80000000000000ULL;
+const uint64_t DF_one = 0x3ff0000000000000ULL;
+const uint64_t DF_one_hh = 0x3ff001ff80000000ULL; /* 1.00048... */
+const uint64_t DF_small_neg = 0xbd731f7500000000ULL;
+const uint64_t DF_large_pos = 0x7f80000000000001ULL;
+
+#endif
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -17,15 +17,19 @@
#include <stdlib.h>
#include <stdio.h>
+#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <pthread.h>
-/* Using volatile because we are testing atomics */
-static inline int atomic_inc32(volatile int *x)
+int err;
+
+#include "hex_test.h"
+
+static inline int32_t atomic_inc32(int32_t *x)
{
- int old, dummy;
+ int32_t old, dummy;
__asm__ __volatile__(
"1: %0 = memw_locked(%2)\n\t"
" %1 = add(%0, #1)\n\t"
@@ -37,10 +41,9 @@ static inline int atomic_inc32(volatile int *x)
return old;
}
-/* Using volatile because we are testing atomics */
-static inline long long atomic_inc64(volatile long long *x)
+static inline int64_t atomic_inc64(int64_t *x)
{
- long long old, dummy;
+ int64_t old, dummy;
__asm__ __volatile__(
"1: %0 = memd_locked(%2)\n\t"
" %1 = #1\n\t"
@@ -53,10 +56,9 @@ static inline long long atomic_inc64(volatile long long *x)
return old;
}
-/* Using volatile because we are testing atomics */
-static inline int atomic_dec32(volatile int *x)
+static inline int32_t atomic_dec32(int32_t *x)
{
- int old, dummy;
+ int32_t old, dummy;
__asm__ __volatile__(
"1: %0 = memw_locked(%2)\n\t"
" %1 = add(%0, #-1)\n\t"
@@ -68,10 +70,9 @@ static inline int atomic_dec32(volatile int *x)
return old;
}
-/* Using volatile because we are testing atomics */
-static inline long long atomic_dec64(volatile long long *x)
+static inline int64_t atomic_dec64(int64_t *x)
{
- long long old, dummy;
+ int64_t old, dummy;
__asm__ __volatile__(
"1: %0 = memd_locked(%2)\n\t"
" %1 = #-1\n\t"
@@ -85,17 +86,12 @@ static inline long long atomic_dec64(volatile long long *x)
}
#define LOOP_CNT 1000
-/* Using volatile because we are testing atomics */
-volatile int tick32 = 1;
-/* Using volatile because we are testing atomics */
-volatile long long tick64 = 1;
-int err;
+volatile int32_t tick32 = 1; /* Using volatile because we are testing atomics */
+volatile int64_t tick64 = 1; /* Using volatile because we are testing atomics */
void *thread1_func(void *arg)
{
- int i;
-
- for (i = 0; i < LOOP_CNT; i++) {
+ for (int i = 0; i < LOOP_CNT; i++) {
atomic_inc32(&tick32);
atomic_dec64(&tick64);
}
@@ -104,8 +100,7 @@ void *thread1_func(void *arg)
void *thread2_func(void *arg)
{
- int i;
- for (i = 0; i < LOOP_CNT; i++) {
+ for (int i = 0; i < LOOP_CNT; i++) {
atomic_dec32(&tick32);
atomic_inc64(&tick64);
}
@@ -121,14 +116,8 @@ void test_pthread(void)
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
- if (tick32 != 1) {
- printf("ERROR: tick32 %d != 1\n", tick32);
- err++;
- }
- if (tick64 != 1) {
- printf("ERROR: tick64 %lld != 1\n", tick64);
- err++;
- }
+ check32(tick32, 1);
+ check64(tick64, 1);
}
int main(int argc, char **argv)
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -17,16 +17,19 @@
#include <stdio.h>
#include <string.h>
+#include <stdint.h>
int err;
+#include "hex_test.h"
+
#define NBITS 8
#define SIZE (1 << NBITS)
-long long dbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
-int wbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
-short hbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
-unsigned char bbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
+int64_t dbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
+int32_t wbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
+int16_t hbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
+uint8_t bbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
/*
* We use the C preporcessor to deal with the combinations of types
@@ -90,11 +93,10 @@ unsigned char bbuf[SIZE] __attribute__((aligned(1 << 16))) = {0};
#define BREV_STORE_wnew(ADDR, VAL, INC) \
BREV_STORE_NEW(w, ADDR, VAL, INC)
-int bitreverse(int x)
+uint32_t bitreverse(uint32_t x)
{
- int result = 0;
- int i;
- for (i = 0; i < NBITS; i++) {
+ uint32_t result = 0;
+ for (int i = 0; i < NBITS; i++) {
result <<= 1;
result |= x & 1;
x >>= 1;
@@ -102,26 +104,18 @@ int bitreverse(int x)
return result;
}
-int sext8(int x)
+int32_t sext8(int32_t x)
{
return (x << 24) >> 24;
}
-void check(int i, long long result, long long expect)
-{
- if (result != expect) {
- printf("ERROR(%d): 0x%04llx != 0x%04llx\n", i, result, expect);
- err++;
- }
-}
-
#define TEST_BREV_LOAD(SZ, TYPE, BUF, SHIFT, EXP) \
do { \
p = BUF; \
- for (i = 0; i < SIZE; i++) { \
+ for (int i = 0; i < SIZE; i++) { \
TYPE result; \
BREV_LOAD_##SZ(result, p, 1 << (SHIFT - NBITS)); \
- check(i, result, EXP); \
+ check32(result, EXP); \
} \
} while (0)
@@ -129,11 +123,11 @@ void check(int i, long long result, long long expect)
do { \
p = BUF; \
memset(BUF, 0xff, sizeof(BUF)); \
- for (i = 0; i < SIZE; i++) { \
+ for (int i = 0; i < SIZE; i++) { \
BREV_STORE_##SZ(p, (TYPE)(VAL), 1 << (SHIFT - NBITS)); \
} \
- for (i = 0; i < SIZE; i++) { \
- check(i, BUF[i], bitreverse(i)); \
+ for (int i = 0; i < SIZE; i++) { \
+ check32(BUF[i], bitreverse(i)); \
} \
} while (0)
@@ -141,11 +135,11 @@ void check(int i, long long result, long long expect)
do { \
p = BUF; \
memset(BUF, 0xff, sizeof(BUF)); \
- for (i = 0; i < SIZE; i++) { \
+ for (int i = 0; i < SIZE; i++) { \
BREV_STORE_##SZ(p, i, 1 << (SHIFT - NBITS)); \
} \
- for (i = 0; i < SIZE; i++) { \
- check(i, BUF[i], bitreverse(i)); \
+ for (int i = 0; i < SIZE; i++) { \
+ check32(BUF[i], bitreverse(i)); \
} \
} while (0)
@@ -158,9 +152,8 @@ int high_half[SIZE];
int main()
{
void *p;
- int i;
- for (i = 0; i < SIZE; i++) {
+ for (int i = 0; i < SIZE; i++) {
bbuf[i] = bitreverse(i);
hbuf[i] = bitreverse(i);
wbuf[i] = bitreverse(i);
@@ -168,18 +161,18 @@ int main()
high_half[i] = i << 16;
}
- TEST_BREV_LOAD(b, int, bbuf, 16, sext8(i));
- TEST_BREV_LOAD(ub, int, bbuf, 16, i);
- TEST_BREV_LOAD(h, int, hbuf, 15, i);
- TEST_BREV_LOAD(uh, int, hbuf, 15, i);
- TEST_BREV_LOAD(w, int, wbuf, 14, i);
- TEST_BREV_LOAD(d, long long, dbuf, 13, i);
-
- TEST_BREV_STORE(b, int, bbuf, i, 16);
- TEST_BREV_STORE(h, int, hbuf, i, 15);
- TEST_BREV_STORE(f, int, hbuf, high_half[i], 15);
- TEST_BREV_STORE(w, int, wbuf, i, 14);
- TEST_BREV_STORE(d, long long, dbuf, i, 13);
+ TEST_BREV_LOAD(b, int32_t, bbuf, 16, sext8(i));
+ TEST_BREV_LOAD(ub, int32_t, bbuf, 16, i);
+ TEST_BREV_LOAD(h, int32_t, hbuf, 15, i);
+ TEST_BREV_LOAD(uh, int32_t, hbuf, 15, i);
+ TEST_BREV_LOAD(w, int32_t, wbuf, 14, i);
+ TEST_BREV_LOAD(d, int64_t, dbuf, 13, i);
+
+ TEST_BREV_STORE(b, int32_t, bbuf, i, 16);
+ TEST_BREV_STORE(h, int32_t, hbuf, i, 15);
+ TEST_BREV_STORE(f, int32_t, hbuf, high_half[i], 15);
+ TEST_BREV_STORE(w, int32_t, wbuf, i, 14);
+ TEST_BREV_STORE(d, int64_t, dbuf, i, 13);
TEST_BREV_STORE_NEW(bnew, bbuf, 16);
TEST_BREV_STORE_NEW(hnew, hbuf, 15);
@@ -16,6 +16,11 @@
*/
#include <stdio.h>
+#include <stdint.h>
+
+int err;
+
+#include "hex_test.h"
#define DEBUG 0
#define DEBUG_PRINTF(...) \
@@ -31,10 +36,10 @@
#define NWORDS (NBYTES / sizeof(int))
#define NDOBLS (NBYTES / sizeof(long long))
-long long dbuf[NDOBLS] __attribute__((aligned(1 << 12))) = {0};
-int wbuf[NWORDS] __attribute__((aligned(1 << 12))) = {0};
-short hbuf[NHALFS] __attribute__((aligned(1 << 12))) = {0};
-unsigned char bbuf[NBYTES] __attribute__((aligned(1 << 12))) = {0};
+int64_t dbuf[NDOBLS] __attribute__((aligned(1 << 12))) = {0};
+int32_t wbuf[NWORDS] __attribute__((aligned(1 << 12))) = {0};
+int16_t hbuf[NHALFS] __attribute__((aligned(1 << 12))) = {0};
+uint8_t bbuf[NBYTES] __attribute__((aligned(1 << 12))) = {0};
/*
* We use the C preporcessor to deal with the combinations of types
@@ -43,8 +48,7 @@ unsigned char bbuf[NBYTES] __attribute__((aligned(1 << 12))) = {0};
#define INIT(BUF, N) \
void init_##BUF(void) \
{ \
- int i; \
- for (i = 0; i < N; i++) { \
+ for (int i = 0; i < N; i++) { \
BUF[i] = i; \
} \
} \
@@ -91,7 +95,7 @@ INIT(dbuf, NDOBLS)
* mreg[23:17] increment[6:0]
* mreg[16:0] circular buffer length
*/
-static int build_mreg(int inc, int K, int len)
+static int32_t build_mreg(int32_t inc, int32_t K, int32_t len)
{
return ((inc & 0x780) << 21) |
((K & 0xf) << 24) |
@@ -213,31 +217,27 @@ static int build_mreg(int inc, int K, int len)
CIRC_STORE_NEW_REG(w, VAL, ADDR, START, LEN, INC)
-int err;
-
/* We'll test increments +1 and -1 */
-void check_load(int i, long long result, int inc, int size)
+void __check_load(int line, int32_t i, int64_t res, int32_t inc, int32_t size)
{
- int expect = (i * inc);
+ int32_t expect = (i * inc);
while (expect >= size) {
expect -= size;
}
while (expect < 0) {
expect += size;
}
- if (result != expect) {
- printf("ERROR(%d): %lld != %d\n", i, result, expect);
- err++;
- }
+ __check32(line, res, expect);
}
+#define check_load(I, RES, INC, SZ) __check_load(__LINE__, I, RES, INC, SZ)
+
#define TEST_LOAD_IMM(SZ, TYPE, BUF, BUFSIZE, INC, FMT) \
void circ_test_load_imm_##SZ(void) \
{ \
TYPE *p = (TYPE *)BUF; \
- int size = 10; \
- int i; \
- for (i = 0; i < BUFSIZE; i++) { \
+ int32_t size = 10; \
+ for (int i = 0; i < BUFSIZE; i++) { \
TYPE element; \
CIRC_LOAD_IMM_##SZ(element, p, BUF, size * sizeof(TYPE), (INC)); \
DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
@@ -245,7 +245,7 @@ void circ_test_load_imm_##SZ(void) \
check_load(i, element, ((INC) / (int)sizeof(TYPE)), size); \
} \
p = (TYPE *)BUF; \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
TYPE element; \
CIRC_LOAD_IMM_##SZ(element, p, BUF, size * sizeof(TYPE), -(INC)); \
DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
@@ -254,20 +254,19 @@ void circ_test_load_imm_##SZ(void) \
} \
}
-TEST_LOAD_IMM(b, char, bbuf, NBYTES, 1, d)
-TEST_LOAD_IMM(ub, unsigned char, bbuf, NBYTES, 1, d)
-TEST_LOAD_IMM(h, short, hbuf, NHALFS, 2, d)
-TEST_LOAD_IMM(uh, unsigned short, hbuf, NHALFS, 2, d)
-TEST_LOAD_IMM(w, int, wbuf, NWORDS, 4, d)
-TEST_LOAD_IMM(d, long long, dbuf, NDOBLS, 8, lld)
+TEST_LOAD_IMM(b, int8_t, bbuf, NBYTES, 1, d)
+TEST_LOAD_IMM(ub, uint8_t, bbuf, NBYTES, 1, d)
+TEST_LOAD_IMM(h, int16_t, hbuf, NHALFS, 2, d)
+TEST_LOAD_IMM(uh, uint16_t, hbuf, NHALFS, 2, d)
+TEST_LOAD_IMM(w, int32_t, wbuf, NWORDS, 4, d)
+TEST_LOAD_IMM(d, int64_t, dbuf, NDOBLS, 8, lld)
#define TEST_LOAD_REG(SZ, TYPE, BUF, BUFSIZE, FMT) \
void circ_test_load_reg_##SZ(void) \
{ \
TYPE *p = (TYPE *)BUF; \
- int size = 13; \
- int i; \
- for (i = 0; i < BUFSIZE; i++) { \
+ int32_t size = 13; \
+ for (int i = 0; i < BUFSIZE; i++) { \
TYPE element; \
CIRC_LOAD_REG_##SZ(element, p, BUF, size * sizeof(TYPE), 1); \
DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
@@ -275,7 +274,7 @@ void circ_test_load_reg_##SZ(void) \
check_load(i, element, 1, size); \
} \
p = (TYPE *)BUF; \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
TYPE element; \
CIRC_LOAD_REG_##SZ(element, p, BUF, size * sizeof(TYPE), -1); \
DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
@@ -284,16 +283,16 @@ void circ_test_load_reg_##SZ(void) \
} \
}
-TEST_LOAD_REG(b, char, bbuf, NBYTES, d)
-TEST_LOAD_REG(ub, unsigned char, bbuf, NBYTES, d)
-TEST_LOAD_REG(h, short, hbuf, NHALFS, d)
-TEST_LOAD_REG(uh, unsigned short, hbuf, NHALFS, d)
-TEST_LOAD_REG(w, int, wbuf, NWORDS, d)
-TEST_LOAD_REG(d, long long, dbuf, NDOBLS, lld)
+TEST_LOAD_REG(b, int8_t, bbuf, NBYTES, d)
+TEST_LOAD_REG(ub, uint8_t, bbuf, NBYTES, d)
+TEST_LOAD_REG(h, int16_t, hbuf, NHALFS, d)
+TEST_LOAD_REG(uh, uint16_t, hbuf, NHALFS, d)
+TEST_LOAD_REG(w, int32_t, wbuf, NWORDS, d)
+TEST_LOAD_REG(d, int64_t, dbuf, NDOBLS, lld)
/* The circular stores will wrap around somewhere inside the buffer */
#define CIRC_VAL(SZ, TYPE, BUFSIZE) \
-TYPE circ_val_##SZ(int i, int inc, int size) \
+TYPE circ_val_##SZ(int i, int32_t inc, int32_t size) \
{ \
int mod = BUFSIZE % size; \
int elem = i * inc; \
@@ -310,33 +309,25 @@ TYPE circ_val_##SZ(int i, int inc, int size) \
} \
}
-CIRC_VAL(b, unsigned char, NBYTES)
-CIRC_VAL(h, short, NHALFS)
-CIRC_VAL(w, int, NWORDS)
-CIRC_VAL(d, long long, NDOBLS)
+CIRC_VAL(b, uint8_t, NBYTES)
+CIRC_VAL(h, int16_t, NHALFS)
+CIRC_VAL(w, int32_t, NWORDS)
+CIRC_VAL(d, int64_t, NDOBLS)
/*
* Circular stores should only write to the first "size" elements of the buffer
* the remainder of the elements should have BUF[i] == i
*/
#define CHECK_STORE(SZ, BUF, BUFSIZE, FMT) \
-void check_store_##SZ(int inc, int size) \
+void check_store_##SZ(int32_t inc, int32_t size) \
{ \
- int i; \
- for (i = 0; i < size; i++) { \
+ for (int i = 0; i < size; i++) { \
DEBUG_PRINTF(#BUF "[%3d] = 0x%02" #FMT ", guess = 0x%02" #FMT "\n", \
i, BUF[i], circ_val_##SZ(i, inc, size)); \
- if (BUF[i] != circ_val_##SZ(i, inc, size)) { \
- printf("ERROR(%3d): 0x%02" #FMT " != 0x%02" #FMT "\n", \
- i, BUF[i], circ_val_##SZ(i, inc, size)); \
- err++; \
- } \
+ check64(BUF[i], circ_val_##SZ(i, inc, size)); \
} \
- for (i = size; i < BUFSIZE; i++) { \
- if (BUF[i] != i) { \
- printf("ERROR(%3d): 0x%02" #FMT " != 0x%02x\n", i, BUF[i], i); \
- err++; \
- } \
+ for (int i = size; i < BUFSIZE; i++) { \
+ check64(BUF[i], i); \
} \
}
@@ -348,12 +339,11 @@ CHECK_STORE(d, dbuf, NDOBLS, llx)
#define CIRC_TEST_STORE_IMM(SZ, CHK, TYPE, BUF, BUFSIZE, SHIFT, INC) \
void circ_test_store_imm_##SZ(void) \
{ \
- unsigned int size = 27; \
+ uint32_t size = 27; \
TYPE *p = BUF; \
TYPE val = 0; \
- int i; \
init_##BUF(); \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
CIRC_STORE_IMM_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), INC); \
val++; \
} \
@@ -361,7 +351,7 @@ void circ_test_store_imm_##SZ(void) \
p = BUF; \
val = 0; \
init_##BUF(); \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
CIRC_STORE_IMM_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), \
-(INC)); \
val++; \
@@ -369,24 +359,23 @@ void circ_test_store_imm_##SZ(void) \
check_store_##CHK((-(INC) / (int)sizeof(TYPE)), size); \
}
-CIRC_TEST_STORE_IMM(b, b, unsigned char, bbuf, NBYTES, 0, 1)
-CIRC_TEST_STORE_IMM(h, h, short, hbuf, NHALFS, 0, 2)
-CIRC_TEST_STORE_IMM(f, h, short, hbuf, NHALFS, 16, 2)
-CIRC_TEST_STORE_IMM(w, w, int, wbuf, NWORDS, 0, 4)
-CIRC_TEST_STORE_IMM(d, d, long long, dbuf, NDOBLS, 0, 8)
-CIRC_TEST_STORE_IMM(bnew, b, unsigned char, bbuf, NBYTES, 0, 1)
-CIRC_TEST_STORE_IMM(hnew, h, short, hbuf, NHALFS, 0, 2)
-CIRC_TEST_STORE_IMM(wnew, w, int, wbuf, NWORDS, 0, 4)
+CIRC_TEST_STORE_IMM(b, b, uint8_t, bbuf, NBYTES, 0, 1)
+CIRC_TEST_STORE_IMM(h, h, int16_t, hbuf, NHALFS, 0, 2)
+CIRC_TEST_STORE_IMM(f, h, int16_t, hbuf, NHALFS, 16, 2)
+CIRC_TEST_STORE_IMM(w, w, int32_t, wbuf, NWORDS, 0, 4)
+CIRC_TEST_STORE_IMM(d, d, int64_t, dbuf, NDOBLS, 0, 8)
+CIRC_TEST_STORE_IMM(bnew, b, uint8_t, bbuf, NBYTES, 0, 1)
+CIRC_TEST_STORE_IMM(hnew, h, int16_t, hbuf, NHALFS, 0, 2)
+CIRC_TEST_STORE_IMM(wnew, w, int32_t, wbuf, NWORDS, 0, 4)
#define CIRC_TEST_STORE_REG(SZ, CHK, TYPE, BUF, BUFSIZE, SHIFT) \
void circ_test_store_reg_##SZ(void) \
{ \
TYPE *p = BUF; \
- unsigned int size = 19; \
+ uint32_t size = 19; \
TYPE val = 0; \
- int i; \
init_##BUF(); \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
CIRC_STORE_REG_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), 1); \
val++; \
} \
@@ -394,35 +383,34 @@ void circ_test_store_reg_##SZ(void) \
p = BUF; \
val = 0; \
init_##BUF(); \
- for (i = 0; i < BUFSIZE; i++) { \
+ for (int i = 0; i < BUFSIZE; i++) { \
CIRC_STORE_REG_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), -1); \
val++; \
} \
check_store_##CHK(-1, size); \
}
-CIRC_TEST_STORE_REG(b, b, unsigned char, bbuf, NBYTES, 0)
-CIRC_TEST_STORE_REG(h, h, short, hbuf, NHALFS, 0)
-CIRC_TEST_STORE_REG(f, h, short, hbuf, NHALFS, 16)
-CIRC_TEST_STORE_REG(w, w, int, wbuf, NWORDS, 0)
-CIRC_TEST_STORE_REG(d, d, long long, dbuf, NDOBLS, 0)
-CIRC_TEST_STORE_REG(bnew, b, unsigned char, bbuf, NBYTES, 0)
-CIRC_TEST_STORE_REG(hnew, h, short, hbuf, NHALFS, 0)
-CIRC_TEST_STORE_REG(wnew, w, int, wbuf, NWORDS, 0)
+CIRC_TEST_STORE_REG(b, b, uint8_t, bbuf, NBYTES, 0)
+CIRC_TEST_STORE_REG(h, h, int16_t, hbuf, NHALFS, 0)
+CIRC_TEST_STORE_REG(f, h, int16_t, hbuf, NHALFS, 16)
+CIRC_TEST_STORE_REG(w, w, int32_t, wbuf, NWORDS, 0)
+CIRC_TEST_STORE_REG(d, d, int64_t, dbuf, NDOBLS, 0)
+CIRC_TEST_STORE_REG(bnew, b, uint8_t, bbuf, NBYTES, 0)
+CIRC_TEST_STORE_REG(hnew, h, int16_t, hbuf, NHALFS, 0)
+CIRC_TEST_STORE_REG(wnew, w, int32_t, wbuf, NWORDS, 0)
/* Test the old scheme used in Hexagon V3 */
static void circ_test_v3(void)
{
int *p = wbuf;
- int size = 15;
+ int32_t size = 15;
/* set high bit in K to test unsigned extract in fcirc */
- int K = 8; /* 1024 bytes */
- int element;
- int i;
+ int32_t K = 8; /* 1024 bytes */
+ int32_t element;
init_wbuf();
- for (i = 0; i < NWORDS; i++) {
+ for (int i = 0; i < NWORDS; i++) {
__asm__(
"r4 = %2\n\t"
"m1 = r4\n\t"
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,13 +16,18 @@
*/
#include <stdio.h>
+#include <stdint.h>
+
+int err;
+
+#include "hex_test.h"
/*
* Make sure that two stores in the same packet honor proper
* semantics: slot 1 executes first, then slot 0.
* This is important when the addresses overlap.
*/
-static inline void dual_stores(int *p, char *q, int x, char y)
+static inline void dual_stores(int32_t *p, int8_t *q, int32_t x, int8_t y)
{
asm volatile("{\n\t"
" memw(%0) = %2\n\t"
@@ -33,27 +38,17 @@ static inline void dual_stores(int *p, char *q, int x, char y)
}
typedef union {
- int word;
- char byte;
+ int32_t word;
+ int8_t byte;
} Dual;
-int err;
-
-static void check(Dual d, int expect)
-{
- if (d.word != expect) {
- printf("ERROR: 0x%08x != 0x%08x\n", d.word, expect);
- err++;
- }
-}
-
int main()
{
Dual d;
d.word = ~0;
dual_stores(&d.word, &d.byte, 0x12345678, 0xff);
- check(d, 0x123456ff);
+ check32(d.word, 0x123456ff);
puts(err ? "FAIL" : "PASS");
return err;
@@ -20,91 +20,44 @@
*/
#include <stdio.h>
+#include <stdint.h>
#include <float.h>
-const int FPINVF_BIT = 1; /* Invalid */
-const int FPINVF = 1 << FPINVF_BIT;
-const int FPDBZF_BIT = 2; /* Divide by zero */
-const int FPDBZF = 1 << FPDBZF_BIT;
-const int FPOVFF_BIT = 3; /* Overflow */
-const int FPOVFF = 1 << FPOVFF_BIT;
-const int FPUNFF_BIT = 4; /* Underflow */
-const int FPUNFF = 1 << FPUNFF_BIT;
-const int FPINPF_BIT = 5; /* Inexact */
-const int FPINPF = 1 << FPINPF_BIT;
-
-const int SF_ZERO = 0x00000000;
-const int SF_NaN = 0x7fc00000;
-const int SF_NaN_special = 0x7f800001;
-const int SF_ANY = 0x3f800000;
-const int SF_HEX_NAN = 0xffffffff;
-const int SF_small_neg = 0xab98fba8;
-const int SF_denorm = 0x00000001;
-const int SF_random = 0x346001d6;
-const int SF_neg_zero = 0x80000000;
-
-const long long DF_QNaN = 0x7ff8000000000000ULL;
-const long long DF_SNaN = 0x7ff7000000000000ULL;
-const long long DF_ANY = 0x3f80000000000000ULL;
-const long long DF_HEX_NAN = 0xffffffffffffffffULL;
-const long long DF_small_neg = 0xbd731f7500000000ULL;
-
int err;
-#define CLEAR_FPSTATUS \
- "r2 = usr\n\t" \
- "r2 = clrbit(r2, #1)\n\t" \
- "r2 = clrbit(r2, #2)\n\t" \
- "r2 = clrbit(r2, #3)\n\t" \
- "r2 = clrbit(r2, #4)\n\t" \
- "r2 = clrbit(r2, #5)\n\t" \
- "usr = r2\n\t"
+#include "hex_test.h"
-static void check_fpstatus_bit(int usr, int expect, int flag, const char *n)
+static void check_fpstatus_bit(uint32_t usr, uint32_t expect, uint32_t flag,
+ const char *name)
{
- int bit = 1 << flag;
+ uint32_t bit = 1 << flag;
if ((usr & bit) != (expect & bit)) {
- printf("ERROR %s: usr = %d, expect = %d\n", n,
+ printf("ERROR %s: usr = %d, expect = %d\n", name,
(usr >> flag) & 1, (expect >> flag) & 1);
err++;
}
}
-static void check_fpstatus(int usr, int expect)
-{
- check_fpstatus_bit(usr, expect, FPINVF_BIT, "Invalid");
- check_fpstatus_bit(usr, expect, FPDBZF_BIT, "Div by zero");
- check_fpstatus_bit(usr, expect, FPOVFF_BIT, "Overflow");
- check_fpstatus_bit(usr, expect, FPUNFF_BIT, "Underflow");
- check_fpstatus_bit(usr, expect, FPINPF_BIT, "Inexact");
-}
-
-static void check32(int val, int expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%x != 0x%x\n", val, expect);
- err++;
- }
-}
-static void check64(unsigned long long val, unsigned long long expect)
+static void check_fpstatus(uint32_t usr, uint32_t expect)
{
- if (val != expect) {
- printf("ERROR: 0x%llx != 0x%llx\n", val, expect);
- err++;
- }
+ check_fpstatus_bit(usr, expect, USR_FPINVF_BIT, "Invalid");
+ check_fpstatus_bit(usr, expect, USR_FPDBZF_BIT, "Div by zero");
+ check_fpstatus_bit(usr, expect, USR_FPOVFF_BIT, "Overflow");
+ check_fpstatus_bit(usr, expect, USR_FPUNFF_BIT, "Underflow");
+ check_fpstatus_bit(usr, expect, USR_FPINPF_BIT, "Inexact");
}
static void check_compare_exception(void)
{
- int cmp;
- int usr;
+ uint32_t cmp;
+ uint32_t usr;
/* Check that FP compares are quiet (don't raise any execptions) */
asm (CLEAR_FPSTATUS
"p0 = sfcmp.eq(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -113,7 +66,7 @@ static void check_compare_exception(void)
"p0 = sfcmp.gt(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -122,7 +75,7 @@ static void check_compare_exception(void)
"p0 = sfcmp.ge(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -131,7 +84,7 @@ static void check_compare_exception(void)
"p0 = dfcmp.eq(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -140,7 +93,7 @@ static void check_compare_exception(void)
"p0 = dfcmp.gt(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -149,7 +102,7 @@ static void check_compare_exception(void)
"p0 = dfcmp.ge(%2, %3)\n\t"
"%0 = p0\n\t"
"%1 = usr\n\t"
- : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(cmp), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "p0", "usr");
check32(cmp, 0);
check_fpstatus(usr, 0);
@@ -157,8 +110,8 @@ static void check_compare_exception(void)
static void check_sfminmax(void)
{
- int minmax;
- int usr;
+ uint32_t minmax;
+ uint32_t usr;
/*
* Execute sfmin/sfmax instructions with one operand as NaN
@@ -169,46 +122,46 @@ static void check_sfminmax(void)
asm (CLEAR_FPSTATUS
"%0 = sfmin(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check64(minmax, SF_ANY);
+ check32(minmax, SF_any);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
"%0 = sfmax(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check64(minmax, SF_ANY);
+ check32(minmax, SF_any);
check_fpstatus(usr, 0);
/*
* Execute sfmin/sfmax instructions with both operands NaN
* Check that
- * Result is SF_HEX_NAN
+ * Result is SF_HEX_NaN
* Invalid bit in USR is set
*/
asm (CLEAR_FPSTATUS
"%0 = sfmin(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(SF_NaN), "r"(SF_NaN)
+ : "=r"(minmax), "=r"(usr) : "r"(SF_QNaN), "r"(SF_QNaN)
: "r2", "usr");
- check64(minmax, SF_HEX_NAN);
+ check32(minmax, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
"%0 = sfmax(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(SF_NaN), "r"(SF_NaN)
+ : "=r"(minmax), "=r"(usr) : "r"(SF_QNaN), "r"(SF_QNaN)
: "r2", "usr");
- check64(minmax, SF_HEX_NAN);
+ check32(minmax, SF_HEX_NaN);
check_fpstatus(usr, 0);
}
static void check_dfminmax(void)
{
- unsigned long long minmax;
- int usr;
+ uint64_t minmax;
+ uint32_t usr;
/*
* Execute dfmin/dfmax instructions with one operand as SNaN
@@ -219,18 +172,18 @@ static void check_dfminmax(void)
asm (CLEAR_FPSTATUS
"%0 = dfmin(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_any)
: "r2", "usr");
- check64(minmax, DF_ANY);
- check_fpstatus(usr, FPINVF);
+ check64(minmax, DF_any);
+ check_fpstatus(usr, USR_FPINVF);
asm (CLEAR_FPSTATUS
"%0 = dfmax(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_any)
: "r2", "usr");
- check64(minmax, DF_ANY);
- check_fpstatus(usr, FPINVF);
+ check64(minmax, DF_any);
+ check_fpstatus(usr, USR_FPINVF);
/*
* Execute dfmin/dfmax instructions with one operand as QNaN
@@ -241,23 +194,23 @@ static void check_dfminmax(void)
asm (CLEAR_FPSTATUS
"%0 = dfmin(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "usr");
- check64(minmax, DF_ANY);
+ check64(minmax, DF_any);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
"%0 = dfmax(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "usr");
- check64(minmax, DF_ANY);
+ check64(minmax, DF_any);
check_fpstatus(usr, 0);
/*
* Execute dfmin/dfmax instructions with both operands SNaN
* Check that
- * Result is DF_HEX_NAN
+ * Result is DF_HEX_NaN
* Invalid bit in USR is set
*/
asm (CLEAR_FPSTATUS
@@ -265,21 +218,21 @@ static void check_dfminmax(void)
"%1 = usr\n\t"
: "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_SNaN)
: "r2", "usr");
- check64(minmax, DF_HEX_NAN);
- check_fpstatus(usr, FPINVF);
+ check64(minmax, DF_HEX_NaN);
+ check_fpstatus(usr, USR_FPINVF);
asm (CLEAR_FPSTATUS
"%0 = dfmax(%2, %3)\n\t"
"%1 = usr\n\t"
: "=r"(minmax), "=r"(usr) : "r"(DF_SNaN), "r"(DF_SNaN)
: "r2", "usr");
- check64(minmax, DF_HEX_NAN);
- check_fpstatus(usr, FPINVF);
+ check64(minmax, DF_HEX_NaN);
+ check_fpstatus(usr, USR_FPINVF);
/*
* Execute dfmin/dfmax instructions with both operands QNaN
* Check that
- * Result is DF_HEX_NAN
+ * Result is DF_HEX_NaN
* No bit in USR is set
*/
asm (CLEAR_FPSTATUS
@@ -287,7 +240,7 @@ static void check_dfminmax(void)
"%1 = usr\n\t"
: "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_QNaN)
: "r2", "usr");
- check64(minmax, DF_HEX_NAN);
+ check64(minmax, DF_HEX_NaN);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
@@ -295,15 +248,15 @@ static void check_dfminmax(void)
"%1 = usr\n\t"
: "=r"(minmax), "=r"(usr) : "r"(DF_QNaN), "r"(DF_QNaN)
: "r2", "usr");
- check64(minmax, DF_HEX_NAN);
+ check64(minmax, DF_HEX_NaN);
check_fpstatus(usr, 0);
}
static void check_sfrecipa(void)
{
- int result;
- int usr;
- int pred;
+ uint32_t result;
+ uint32_t usr;
+ uint32_t pred;
/*
* Check that sfrecipa doesn't set status bits when
@@ -312,25 +265,25 @@ static void check_sfrecipa(void)
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
+ check32(result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_ANY), "r"(SF_NaN)
+ : "=r"(result), "=r"(usr) : "r"(SF_any), "r"(SF_QNaN)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
+ check32(result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %2)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(result), "=r"(usr) : "r"(SF_QNaN)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
+ check32(result, SF_HEX_NaN);
check_fpstatus(usr, 0);
/*
@@ -340,26 +293,26 @@ static void check_sfrecipa(void)
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_NaN_special), "r"(SF_ANY)
+ : "=r"(result), "=r"(usr) : "r"(SF_QNaN_special), "r"(SF_any)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
- check_fpstatus(usr, FPINVF);
+ check32(result, SF_HEX_NaN);
+ check_fpstatus(usr, USR_FPINVF);
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_ANY), "r"(SF_NaN_special)
+ : "=r"(result), "=r"(usr) : "r"(SF_any), "r"(SF_QNaN_special)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
- check_fpstatus(usr, FPINVF);
+ check32(result, SF_HEX_NaN);
+ check_fpstatus(usr, USR_FPINVF);
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %2)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(SF_NaN_special)
+ : "=r"(result), "=r"(usr) : "r"(SF_QNaN_special)
: "r2", "p0", "usr");
- check32(result, SF_HEX_NAN);
- check_fpstatus(usr, FPINVF);
+ check32(result, SF_HEX_NaN);
+ check_fpstatus(usr, USR_FPINVF);
/*
* Check that sfrecipa properly sets divid-by-zero
@@ -370,12 +323,12 @@ static void check_sfrecipa(void)
: "=r"(result), "=r"(usr) : "r"(0x885dc960), "r"(0x80000000)
: "r2", "p0", "usr");
check32(result, 0x3f800000);
- check_fpstatus(usr, FPDBZF);
+ check_fpstatus(usr, USR_FPDBZF);
asm (CLEAR_FPSTATUS
"%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(result), "=r"(usr) : "r"(0x7f800000), "r"(SF_ZERO)
+ : "=r"(result), "=r"(usr) : "r"(0x7f800000), "r"(SF_zero)
: "r2", "p0", "usr");
check32(result, 0x3f800000);
check_fpstatus(usr, 0);
@@ -394,79 +347,79 @@ static void check_sfrecipa(void)
static void check_canonical_NaN(void)
{
- int sf_result;
- unsigned long long df_result;
- int usr;
+ uint32_t sf_result;
+ uint64_t df_result;
+ uint32_t usr;
- /* Check that each FP instruction properly returns SF_HEX_NAN/DF_HEX_NAN */
+ /* Check that each FP instruction properly returns SF_HEX_NaN/DF_HEX_NaN */
asm(CLEAR_FPSTATUS
"%0 = sfadd(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
"%0 = sfsub(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
"%0 = sfmpy(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "=r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
- sf_result = SF_ZERO;
+ sf_result = SF_zero;
asm(CLEAR_FPSTATUS
"%0 += sfmpy(%2, %3)\n\t"
"%1 = usr\n\t"
- : "+r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "+r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
- sf_result = SF_ZERO;
+ sf_result = SF_zero;
asm(CLEAR_FPSTATUS
"p0 = !cmp.eq(r0, r0)\n\t"
"%0 += sfmpy(%2, %3, p0):scale\n\t"
"%1 = usr\n\t"
- : "+r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "+r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr", "p0");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
- sf_result = SF_ZERO;
+ sf_result = SF_zero;
asm(CLEAR_FPSTATUS
"%0 -= sfmpy(%2, %3)\n\t"
"%1 = usr\n\t"
- : "+r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "+r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
- sf_result = SF_ZERO;
+ sf_result = SF_zero;
asm(CLEAR_FPSTATUS
"%0 += sfmpy(%2, %3):lib\n\t"
"%1 = usr\n\t"
- : "+r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "+r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
- sf_result = SF_ZERO;
+ sf_result = SF_zero;
asm(CLEAR_FPSTATUS
"%0 -= sfmpy(%2, %3):lib\n\t"
"%1 = usr\n\t"
- : "+r"(sf_result), "=r"(usr) : "r"(SF_NaN), "r"(SF_ANY)
+ : "+r"(sf_result), "=r"(usr) : "r"(SF_QNaN), "r"(SF_any)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
@@ -474,38 +427,38 @@ static void check_canonical_NaN(void)
"%1 = usr\n\t"
: "=r"(sf_result), "=r"(usr) : "r"(DF_QNaN)
: "r2", "usr");
- check32(sf_result, SF_HEX_NAN);
+ check32(sf_result, SF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
"%0 = dfadd(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(df_result), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(df_result), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "usr");
- check64(df_result, DF_HEX_NAN);
+ check64(df_result, DF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
"%0 = dfsub(%2, %3)\n\t"
"%1 = usr\n\t"
- : "=r"(df_result), "=r"(usr) : "r"(DF_QNaN), "r"(DF_ANY)
+ : "=r"(df_result), "=r"(usr) : "r"(DF_QNaN), "r"(DF_any)
: "r2", "usr");
- check64(df_result, DF_HEX_NAN);
+ check64(df_result, DF_HEX_NaN);
check_fpstatus(usr, 0);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2df(%2)\n\t"
"%1 = usr\n\t"
- : "=r"(df_result), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(df_result), "=r"(usr) : "r"(SF_QNaN)
: "r2", "usr");
- check64(df_result, DF_HEX_NAN);
+ check64(df_result, DF_HEX_NaN);
check_fpstatus(usr, 0);
}
static void check_invsqrta(void)
{
- int result;
- int predval;
+ uint32_t result;
+ uint32_t predval;
asm volatile("%0,p0 = sfinvsqrta(%2)\n\t"
"%1 = p0\n\t"
@@ -518,7 +471,7 @@ static void check_invsqrta(void)
static void check_sffixupn(void)
{
- int result;
+ uint32_t result;
/* Check that sffixupn properly deals with denorm */
asm volatile("%0 = sffixupn(%1, %2)\n\t"
@@ -529,7 +482,7 @@ static void check_sffixupn(void)
static void check_sffixupd(void)
{
- int result;
+ uint32_t result;
/* Check that sffixupd properly deals with denorm */
asm volatile("%0 = sffixupd(%1, %2)\n\t"
@@ -540,36 +493,36 @@ static void check_sffixupd(void)
static void check_sffms(void)
{
- int result;
+ uint32_t result;
/* Check that sffms properly deals with -0 */
- result = SF_neg_zero;
+ result = SF_zero_neg;
asm ("%0 -= sfmpy(%1 , %2)\n\t"
: "+r"(result)
- : "r"(SF_ZERO), "r"(SF_ZERO)
+ : "r"(SF_zero), "r"(SF_zero)
: "r12", "r8");
- check32(result, SF_neg_zero);
+ check32(result, SF_zero_neg);
- result = SF_ZERO;
+ result = SF_zero;
asm ("%0 -= sfmpy(%1 , %2)\n\t"
: "+r"(result)
- : "r"(SF_neg_zero), "r"(SF_ZERO)
+ : "r"(SF_zero_neg), "r"(SF_zero)
: "r12", "r8");
- check32(result, SF_ZERO);
+ check32(result, SF_zero);
- result = SF_ZERO;
+ result = SF_zero;
asm ("%0 -= sfmpy(%1 , %2)\n\t"
: "+r"(result)
- : "r"(SF_ZERO), "r"(SF_neg_zero)
+ : "r"(SF_zero), "r"(SF_zero_neg)
: "r12", "r8");
- check32(result, SF_ZERO);
+ check32(result, SF_zero);
}
static void check_float2int_convs()
{
- int res32;
- long long res64;
- int usr;
+ uint32_t res32;
+ uint64_t res64;
+ uint32_t usr;
/*
* Check that the various forms of float-to-unsigned
@@ -581,7 +534,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(SF_small_neg)
: "r2", "usr");
check32(res32, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2uw(%2):chop\n\t"
@@ -589,7 +542,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(SF_small_neg)
: "r2", "usr");
check32(res32, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2ud(%2)\n\t"
@@ -597,7 +550,7 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(SF_small_neg)
: "r2", "usr");
check64(res64, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2ud(%2):chop\n\t"
@@ -605,7 +558,7 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(SF_small_neg)
: "r2", "usr");
check64(res64, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2uw(%2)\n\t"
@@ -613,7 +566,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(DF_small_neg)
: "r2", "usr");
check32(res32, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2uw(%2):chop\n\t"
@@ -621,7 +574,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(DF_small_neg)
: "r2", "usr");
check32(res32, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2ud(%2)\n\t"
@@ -629,7 +582,7 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(DF_small_neg)
: "r2", "usr");
check64(res64, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2ud(%2):chop\n\t"
@@ -637,7 +590,7 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(DF_small_neg)
: "r2", "usr");
check64(res64, 0);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
/*
* Check that the various forms of float-to-signed return -1 for NaN
@@ -645,34 +598,34 @@ static void check_float2int_convs()
asm(CLEAR_FPSTATUS
"%0 = convert_sf2w(%2)\n\t"
"%1 = usr\n\t"
- : "=r"(res32), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(res32), "=r"(usr) : "r"(SF_QNaN)
: "r2", "usr");
check32(res32, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2w(%2):chop\n\t"
"%1 = usr\n\t"
- : "=r"(res32), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(res32), "=r"(usr) : "r"(SF_QNaN)
: "r2", "usr");
check32(res32, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2d(%2)\n\t"
"%1 = usr\n\t"
- : "=r"(res64), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(res64), "=r"(usr) : "r"(SF_QNaN)
: "r2", "usr");
check64(res64, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_sf2d(%2):chop\n\t"
"%1 = usr\n\t"
- : "=r"(res64), "=r"(usr) : "r"(SF_NaN)
+ : "=r"(res64), "=r"(usr) : "r"(SF_QNaN)
: "r2", "usr");
check64(res64, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2w(%2)\n\t"
@@ -680,7 +633,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(DF_QNaN)
: "r2", "usr");
check32(res32, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2w(%2):chop\n\t"
@@ -688,7 +641,7 @@ static void check_float2int_convs()
: "=r"(res32), "=r"(usr) : "r"(DF_QNaN)
: "r2", "usr");
check32(res32, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2d(%2)\n\t"
@@ -696,7 +649,7 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(DF_QNaN)
: "r2", "usr");
check64(res64, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
asm(CLEAR_FPSTATUS
"%0 = convert_df2d(%2):chop\n\t"
@@ -704,13 +657,13 @@ static void check_float2int_convs()
: "=r"(res64), "=r"(usr) : "r"(DF_QNaN)
: "r2", "usr");
check64(res64, -1);
- check_fpstatus(usr, FPINVF);
+ check_fpstatus(usr, USR_FPINVF);
}
static void check_float_consts(void)
{
- int res32;
- unsigned long long res64;
+ uint32_t res32;
+ uint64_t res64;
asm("%0 = sfmake(#%1):neg\n\t" : "=r"(res32) : "i"(0xf));
check32(res32, 0xbc9e0000);
@@ -725,23 +678,23 @@ static void check_float_consts(void)
check64(res64, 0x3f93c00000000000ULL);
}
-static inline unsigned long long dfmpyll(double x, double y)
+static inline uint64_t dfmpyll(double x, double y)
{
- unsigned long long res64;
+ uint64_t res64;
asm("%0 = dfmpyll(%1, %2)" : "=r"(res64) : "r"(x), "r"(y));
return res64;
}
-static inline unsigned long long dfmpylh(double acc, double x, double y)
+static inline uint64_t dfmpylh(double acc, double x, double y)
{
- unsigned long long res64 = *(unsigned long long *)&acc;
+ uint64_t res64 = *(uint64_t *)&acc;
asm("%0 += dfmpylh(%1, %2)" : "+r"(res64) : "r"(x), "r"(y));
return res64;
}
static void check_dfmpyxx(void)
{
- unsigned long long res64;
+ uint64_t res64;
res64 = dfmpyll(DBL_MIN, DBL_MIN);
check64(res64, 0ULL);
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2021-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -25,6 +25,8 @@
*/
#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
@@ -32,45 +34,23 @@
#include <setjmp.h>
#include <signal.h>
-typedef unsigned char uint8_t;
-
int err;
-int segv_caught;
-
-#define SHOULD_NOT_CHANGE_VAL 5
-int should_not_change = SHOULD_NOT_CHANGE_VAL;
-
-#define BUF_SIZE 300
-unsigned char buf[BUF_SIZE];
+#include "hex_test.h"
-static void __check(const char *filename, int line, int x, int expect)
-{
- if (x != expect) {
- printf("ERROR %s:%d - %d != %d\n",
- filename, line, x, expect);
- err++;
- }
-}
+bool segv_caught;
-#define check(x, expect) __check(__FILE__, __LINE__, (x), (expect))
-
-static void __chk_error(const char *filename, int line, int ret)
-{
- if (ret < 0) {
- printf("ERROR %s:%d - %d\n", filename, line, ret);
- err++;
- }
-}
-
-#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))
+#define SHOULD_NOT_CHANGE_VAL 5
+int32_t should_not_change = SHOULD_NOT_CHANGE_VAL;
+#define BUF_SIZE 300
+uint8_t buf[BUF_SIZE];
jmp_buf jmp_env;
static void sig_segv(int sig, siginfo_t *info, void *puc)
{
- check(sig, SIGSEGV);
- segv_caught = 1;
+ check32(sig, SIGSEGV);
+ segv_caught = true;
longjmp(jmp_env, 1);
}
@@ -98,8 +78,8 @@ int main()
act.sa_flags = 0;
chk_error(sigaction(SIGSEGV, &act, NULL));
- check(segv_caught, 1);
- check(should_not_change, SHOULD_NOT_CHANGE_VAL);
+ check32(segv_caught, true);
+ check32(should_not_change, SHOULD_NOT_CHANGE_VAL);
puts(err ? "FAIL" : "PASS");
return err ? EXIT_FAILURE : EXIT_SUCCESS;
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -29,41 +29,22 @@
*/
#include <stdio.h>
+#include <stdint.h>
#include <string.h>
int err;
-char buf[16] __attribute__((aligned(1 << 16)));
+#include "hex_test.h"
+
+int8_t buf[16] __attribute__((aligned(1 << 16)));
void init_buf(void)
{
- int i;
- for (i = 0; i < 16; i++) {
+ for (int i = 0; i < 16; i++) {
buf[i] = i + 1;
}
}
-void __check(int line, long long result, long long expect)
-{
- if (result != expect) {
- printf("ERROR at line %d: 0x%016llx != 0x%016llx\n",
- line, result, expect);
- err++;
- }
-}
-
-#define check(RES, EXP) __check(__LINE__, RES, EXP)
-
-void __checkp(int line, void *p, void *expect)
-{
- if (p != expect) {
- printf("ERROR at line %d: 0x%p != 0x%p\n", line, p, expect);
- err++;
- }
-}
-
-#define checkp(RES, EXP) __checkp(__LINE__, RES, EXP)
-
/*
****************************************************************************
* _io addressing mode (addr + offset)
@@ -81,15 +62,15 @@ void __checkp(int line, void *p, void *expect)
#define TEST_io(NAME, SZ, SIZE, EXP1, EXP2, EXP3, EXP4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
LOAD_io_##SZ(result, buf, 0 * (SIZE)); \
- check(result, (EXP1)); \
+ check64(result, (EXP1)); \
LOAD_io_##SZ(result, buf, 1 * (SIZE)); \
- check(result, (EXP2)); \
+ check64(result, (EXP2)); \
LOAD_io_##SZ(result, buf, 2 * (SIZE)); \
- check(result, (EXP3)); \
+ check64(result, (EXP3)); \
LOAD_io_##SZ(result, buf, 3 * (SIZE)); \
- check(result, (EXP4)); \
+ check64(result, (EXP4)); \
}
TEST_io(loadalignb_io, b, 1,
@@ -116,15 +97,15 @@ TEST_io(loadalignh_io, h, 2,
#define TEST_ur(NAME, SZ, SHIFT, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ uint64_t result = ~0LL; \
LOAD_ur_##SZ(result, (SHIFT), 0); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
LOAD_ur_##SZ(result, (SHIFT), 1); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
LOAD_ur_##SZ(result, (SHIFT), 2); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
LOAD_ur_##SZ(result, (SHIFT), 3); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
}
TEST_ur(loadalignb_ur, b, 1,
@@ -150,19 +131,19 @@ TEST_ur(loadalignh_ur, h, 1,
#define TEST_ap(NAME, SZ, SIZE, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr; \
LOAD_ap_##SZ(result, ptr, (buf + 0 * (SIZE))); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
checkp(ptr, &buf[0 * (SIZE)]); \
LOAD_ap_##SZ(result, ptr, (buf + 1 * (SIZE))); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
checkp(ptr, &buf[1 * (SIZE)]); \
LOAD_ap_##SZ(result, ptr, (buf + 2 * (SIZE))); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
checkp(ptr, &buf[2 * (SIZE)]); \
LOAD_ap_##SZ(result, ptr, (buf + 3 * (SIZE))); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
checkp(ptr, &buf[3 * (SIZE)]); \
}
@@ -192,19 +173,19 @@ TEST_ap(loadalignh_ap, h, 2,
#define TEST_pr(NAME, SZ, SIZE, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr = buf; \
LOAD_pr_##SZ(result, ptr, (SIZE)); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
checkp(ptr, &buf[1 * (SIZE)]); \
LOAD_pr_##SZ(result, ptr, (SIZE)); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
checkp(ptr, &buf[2 * (SIZE)]); \
LOAD_pr_##SZ(result, ptr, (SIZE)); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
checkp(ptr, &buf[3 * (SIZE)]); \
LOAD_pr_##SZ(result, ptr, (SIZE)); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
checkp(ptr, &buf[4 * (SIZE)]); \
}
@@ -235,16 +216,16 @@ TEST_pr(loadalignh_pr, h, 2,
#define TEST_pbr(NAME, SZ, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr = buf; \
LOAD_pbr_##SZ(result, ptr); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
LOAD_pbr_##SZ(result, ptr); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
LOAD_pbr_##SZ(result, ptr); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
LOAD_pbr_##SZ(result, ptr); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
}
TEST_pbr(loadalignb_pbr, b,
@@ -270,19 +251,19 @@ TEST_pbr(loadalignh_pbr, h,
#define TEST_pi(NAME, SZ, INC, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr = buf; \
LOAD_pi_##SZ(result, ptr, (INC)); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
checkp(ptr, &buf[1 * (INC)]); \
LOAD_pi_##SZ(result, ptr, (INC)); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
checkp(ptr, &buf[2 * (INC)]); \
LOAD_pi_##SZ(result, ptr, (INC)); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
checkp(ptr, &buf[3 * (INC)]); \
LOAD_pi_##SZ(result, ptr, (INC)); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
checkp(ptr, &buf[4 * (INC)]); \
}
@@ -314,19 +295,19 @@ TEST_pi(loadalignh_pi, h, 2,
#define TEST_pci(NAME, SZ, LEN, INC, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr = buf; \
LOAD_pci_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
checkp(ptr, &buf[(1 * (INC)) % (LEN)]); \
LOAD_pci_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
checkp(ptr, &buf[(2 * (INC)) % (LEN)]); \
LOAD_pci_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
checkp(ptr, &buf[(3 * (INC)) % (LEN)]); \
LOAD_pci_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
checkp(ptr, &buf[(4 * (INC)) % (LEN)]); \
}
@@ -359,19 +340,19 @@ TEST_pci(loadalignh_pci, h, 4, 2,
#define TEST_pcr(NAME, SZ, SIZE, LEN, INC, RES1, RES2, RES3, RES4) \
void test_##NAME(void) \
{ \
- long long result = ~0LL; \
+ int64_t result = ~0LL; \
void *ptr = buf; \
LOAD_pcr_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES1)); \
+ check64(result, (RES1)); \
checkp(ptr, &buf[(1 * (INC) * (SIZE)) % (LEN)]); \
LOAD_pcr_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES2)); \
+ check64(result, (RES2)); \
checkp(ptr, &buf[(2 * (INC) * (SIZE)) % (LEN)]); \
LOAD_pcr_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES3)); \
+ check64(result, (RES3)); \
checkp(ptr, &buf[(3 * (INC) * (SIZE)) % (LEN)]); \
LOAD_pcr_##SZ(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES4)); \
+ check64(result, (RES4)); \
checkp(ptr, &buf[(4 * (INC) * (SIZE)) % (LEN)]); \
}
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -31,42 +31,23 @@
*/
#include <stdio.h>
+#include <stdint.h>
#include <string.h>
int err;
-char buf[16] __attribute__((aligned(1 << 16)));
+#include "hex_test.h"
+
+int8_t buf[16] __attribute__((aligned(1 << 16)));
void init_buf(void)
{
- int i;
- for (i = 0; i < 16; i++) {
+ for (int i = 0; i < 16; i++) {
int sign = i % 2 == 0 ? 0x80 : 0;
buf[i] = sign | (i + 1);
}
}
-void __check(int line, long long result, long long expect)
-{
- if (result != expect) {
- printf("ERROR at line %d: 0x%08llx != 0x%08llx\n",
- line, result, expect);
- err++;
- }
-}
-
-#define check(RES, EXP) __check(__LINE__, RES, EXP)
-
-void __checkp(int line, void *p, void *expect)
-{
- if (p != expect) {
- printf("ERROR at line %d: 0x%p != 0x%p\n", line, p, expect);
- err++;
- }
-}
-
-#define checkp(RES, EXP) __checkp(__LINE__, RES, EXP)
-
/*
****************************************************************************
* _io addressing mode (addr + offset)
@@ -87,24 +68,24 @@ void test_##NAME(void) \
TYPE result; \
init_buf(); \
BxW_LOAD_io_##SIGN(result, buf, 0 * (SIZE)); \
- check(result, (EXP1) | (EXT)); \
+ check64(result, (EXP1) | (EXT)); \
BxW_LOAD_io_##SIGN(result, buf, 1 * (SIZE)); \
- check(result, (EXP2) | (EXT)); \
+ check64(result, (EXP2) | (EXT)); \
BxW_LOAD_io_##SIGN(result, buf, 2 * (SIZE)); \
- check(result, (EXP3) | (EXT)); \
+ check64(result, (EXP3) | (EXT)); \
BxW_LOAD_io_##SIGN(result, buf, 3 * (SIZE)); \
- check(result, (EXP4) | (EXT)); \
+ check64(result, (EXP4) | (EXT)); \
}
-TEST_io(loadbzw2_io, int, Z, 2, 0x00000000,
+TEST_io(loadbzw2_io, int32_t, Z, 2, 0x00000000,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_io(loadbsw2_io, int, S, 2, 0x0000ff00,
+TEST_io(loadbsw2_io, int32_t, S, 2, 0x0000ff00,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_io(loadbzw4_io, long long, Z, 4, 0x0000000000000000LL,
+TEST_io(loadbzw4_io, int64_t, Z, 4, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
-TEST_io(loadbsw4_io, long long, S, 4, 0x0000ff000000ff00LL,
+TEST_io(loadbsw4_io, int64_t, S, 4, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
@@ -128,23 +109,23 @@ void test_##NAME(void) \
TYPE result; \
init_buf(); \
BxW_LOAD_ur_##SIGN(result, (SHIFT), 0); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
BxW_LOAD_ur_##SIGN(result, (SHIFT), 1); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
BxW_LOAD_ur_##SIGN(result, (SHIFT), 2); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
BxW_LOAD_ur_##SIGN(result, (SHIFT), 3); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
} \
-TEST_ur(loadbzw2_ur, int, Z, 1, 0x00000000,
+TEST_ur(loadbzw2_ur, int32_t, Z, 1, 0x00000000,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_ur(loadbsw2_ur, int, S, 1, 0x0000ff00,
+TEST_ur(loadbsw2_ur, int32_t, S, 1, 0x0000ff00,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_ur(loadbzw4_ur, long long, Z, 2, 0x0000000000000000LL,
+TEST_ur(loadbzw4_ur, int64_t, Z, 2, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
-TEST_ur(loadbsw4_ur, long long, S, 2, 0x0000ff000000ff00LL,
+TEST_ur(loadbsw4_ur, int64_t, S, 2, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
@@ -168,27 +149,27 @@ void test_##NAME(void) \
void *ptr; \
init_buf(); \
BxW_LOAD_ap_##SIGN(result, ptr, (buf + 0 * (SIZE))); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
checkp(ptr, &buf[0 * (SIZE)]); \
BxW_LOAD_ap_##SIGN(result, ptr, (buf + 1 * (SIZE))); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
checkp(ptr, &buf[1 * (SIZE)]); \
BxW_LOAD_ap_##SIGN(result, ptr, (buf + 2 * (SIZE))); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
checkp(ptr, &buf[2 * (SIZE)]); \
BxW_LOAD_ap_##SIGN(result, ptr, (buf + 3 * (SIZE))); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
checkp(ptr, &buf[3 * (SIZE)]); \
}
-TEST_ap(loadbzw2_ap, int, Z, 2, 0x00000000,
+TEST_ap(loadbzw2_ap, int32_t, Z, 2, 0x00000000,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_ap(loadbsw2_ap, int, S, 2, 0x0000ff00,
+TEST_ap(loadbsw2_ap, int32_t, S, 2, 0x0000ff00,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_ap(loadbzw4_ap, long long, Z, 4, 0x0000000000000000LL,
+TEST_ap(loadbzw4_ap, int64_t, Z, 4, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
-TEST_ap(loadbsw4_ap, long long, S, 4, 0x0000ff000000ff00LL,
+TEST_ap(loadbsw4_ap, int64_t, S, 4, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
@@ -215,27 +196,27 @@ void test_##NAME(void) \
void *ptr = buf; \
init_buf(); \
BxW_LOAD_pr_##SIGN(result, ptr, (SIZE)); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
checkp(ptr, &buf[1 * (SIZE)]); \
BxW_LOAD_pr_##SIGN(result, ptr, (SIZE)); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
checkp(ptr, &buf[2 * (SIZE)]); \
BxW_LOAD_pr_##SIGN(result, ptr, (SIZE)); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
checkp(ptr, &buf[3 * (SIZE)]); \
BxW_LOAD_pr_##SIGN(result, ptr, (SIZE)); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
checkp(ptr, &buf[4 * (SIZE)]); \
}
-TEST_pr(loadbzw2_pr, int, Z, 2, 0x00000000,
+TEST_pr(loadbzw2_pr, int32_t, Z, 2, 0x00000000,
0x00020081, 0x0040083, 0x00060085, 0x00080087)
-TEST_pr(loadbsw2_pr, int, S, 2, 0x0000ff00,
+TEST_pr(loadbsw2_pr, int32_t, S, 2, 0x0000ff00,
0x00020081, 0x0040083, 0x00060085, 0x00080087)
-TEST_pr(loadbzw4_pr, long long, Z, 4, 0x0000000000000000LL,
+TEST_pr(loadbzw4_pr, int64_t, Z, 4, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
-TEST_pr(loadbsw4_pr, long long, S, 4, 0x0000ff000000ff00LL,
+TEST_pr(loadbsw4_pr, int64_t, S, 4, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
@@ -263,23 +244,23 @@ void test_##NAME(void) \
void *ptr = buf; \
init_buf(); \
BxW_LOAD_pbr_##SIGN(result, ptr); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
BxW_LOAD_pbr_##SIGN(result, ptr); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
BxW_LOAD_pbr_##SIGN(result, ptr); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
BxW_LOAD_pbr_##SIGN(result, ptr); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
}
-TEST_pbr(loadbzw2_pbr, int, Z, 0x00000000,
+TEST_pbr(loadbzw2_pbr, int32_t, Z, 0x00000000,
0x00020081, 0x000a0089, 0x00060085, 0x000e008d)
-TEST_pbr(loadbsw2_pbr, int, S, 0x0000ff00,
+TEST_pbr(loadbsw2_pbr, int32_t, S, 0x0000ff00,
0x00020081, 0x000aff89, 0x0006ff85, 0x000eff8d)
-TEST_pbr(loadbzw4_pbr, long long, Z, 0x0000000000000000LL,
+TEST_pbr(loadbzw4_pbr, int64_t, Z, 0x0000000000000000LL,
0x0004008300020081LL, 0x000c008b000a0089LL,
0x0008008700060085LL, 0x0010008f000e008dLL)
-TEST_pbr(loadbsw4_pbr, long long, S, 0x0000ff000000ff00LL,
+TEST_pbr(loadbsw4_pbr, int64_t, S, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x000cff8b000aff89LL,
0x0008ff870006ff85LL, 0x0010ff8f000eff8dLL)
@@ -303,27 +284,27 @@ void test_##NAME(void) \
void *ptr = buf; \
init_buf(); \
BxW_LOAD_pi_##SIGN(result, ptr, (INC)); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
checkp(ptr, &buf[1 * (INC)]); \
BxW_LOAD_pi_##SIGN(result, ptr, (INC)); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
checkp(ptr, &buf[2 * (INC)]); \
BxW_LOAD_pi_##SIGN(result, ptr, (INC)); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
checkp(ptr, &buf[3 * (INC)]); \
BxW_LOAD_pi_##SIGN(result, ptr, (INC)); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
checkp(ptr, &buf[4 * (INC)]); \
}
-TEST_pi(loadbzw2_pi, int, Z, 2, 0x00000000,
+TEST_pi(loadbzw2_pi, int32_t, Z, 2, 0x00000000,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_pi(loadbsw2_pi, int, S, 2, 0x0000ff00,
+TEST_pi(loadbsw2_pi, int32_t, S, 2, 0x0000ff00,
0x00020081, 0x00040083, 0x00060085, 0x00080087)
-TEST_pi(loadbzw4_pi, long long, Z, 4, 0x0000000000000000LL,
+TEST_pi(loadbzw4_pi, int64_t, Z, 4, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
-TEST_pi(loadbsw4_pi, long long, S, 4, 0x0000ff000000ff00LL,
+TEST_pi(loadbsw4_pi, int64_t, S, 4, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x000c008b000a0089LL, 0x0010008f000e008dLL)
@@ -352,27 +333,27 @@ void test_##NAME(void) \
void *ptr = buf; \
init_buf(); \
BxW_LOAD_pci_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
checkp(ptr, &buf[(1 * (INC)) % (LEN)]); \
BxW_LOAD_pci_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
checkp(ptr, &buf[(2 * (INC)) % (LEN)]); \
BxW_LOAD_pci_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
checkp(ptr, &buf[(3 * (INC)) % (LEN)]); \
BxW_LOAD_pci_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
checkp(ptr, &buf[(4 * (INC)) % (LEN)]); \
}
-TEST_pci(loadbzw2_pci, int, Z, 6, 2, 0x00000000,
+TEST_pci(loadbzw2_pci, int32_t, Z, 6, 2, 0x00000000,
0x00020081, 0x00040083, 0x00060085, 0x00020081)
-TEST_pci(loadbsw2_pci, int, S, 6, 2, 0x0000ff00,
+TEST_pci(loadbsw2_pci, int32_t, S, 6, 2, 0x0000ff00,
0x00020081, 0x00040083, 0x00060085, 0x00020081)
-TEST_pci(loadbzw4_pci, long long, Z, 8, 4, 0x0000000000000000LL,
+TEST_pci(loadbzw4_pci, int64_t, Z, 8, 4, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x0004008300020081LL, 0x0008008700060085LL)
-TEST_pci(loadbsw4_pci, long long, S, 8, 4, 0x0000ff000000ff00LL,
+TEST_pci(loadbsw4_pci, int64_t, S, 8, 4, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x0004008300020081LL, 0x0008008700060085LL)
@@ -403,27 +384,27 @@ void test_##NAME(void) \
void *ptr = buf; \
init_buf(); \
BxW_LOAD_pcr_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES1) | (EXT)); \
+ check64(result, (RES1) | (EXT)); \
checkp(ptr, &buf[(1 * (INC) * (SIZE)) % (LEN)]); \
BxW_LOAD_pcr_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES2) | (EXT)); \
+ check64(result, (RES2) | (EXT)); \
checkp(ptr, &buf[(2 * (INC) * (SIZE)) % (LEN)]); \
BxW_LOAD_pcr_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES3) | (EXT)); \
+ check64(result, (RES3) | (EXT)); \
checkp(ptr, &buf[(3 * (INC) * (SIZE)) % (LEN)]); \
BxW_LOAD_pcr_##SIGN(result, ptr, buf, (LEN), (INC)); \
- check(result, (RES4) | (EXT)); \
+ check64(result, (RES4) | (EXT)); \
checkp(ptr, &buf[(4 * (INC) * (SIZE)) % (LEN)]); \
}
-TEST_pcr(loadbzw2_pcr, int, Z, 2, 8, 2, 0x00000000,
+TEST_pcr(loadbzw2_pcr, int32_t, Z, 2, 8, 2, 0x00000000,
0x00020081, 0x00060085, 0x00020081, 0x00060085)
-TEST_pcr(loadbsw2_pcr, int, S, 2, 8, 2, 0x0000ff00,
+TEST_pcr(loadbsw2_pcr, int32_t, S, 2, 8, 2, 0x0000ff00,
0x00020081, 0x00060085, 0x00020081, 0x00060085)
-TEST_pcr(loadbzw4_pcr, long long, Z, 4, 8, 1, 0x0000000000000000LL,
+TEST_pcr(loadbzw4_pcr, int64_t, Z, 4, 8, 1, 0x0000000000000000LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x0004008300020081LL, 0x0008008700060085LL)
-TEST_pcr(loadbsw4_pcr, long long, S, 4, 8, 1, 0x0000ff000000ff00LL,
+TEST_pcr(loadbsw4_pcr, int64_t, S, 4, 8, 1, 0x0000ff000000ff00LL,
0x0004008300020081LL, 0x0008008700060085LL,
0x0004008300020081LL, 0x0008008700060085LL)
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2022 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,6 +16,12 @@
*/
#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+int err;
+
+#include "hex_test.h"
/*
* Make sure that the :mem_noshuf packet attribute is honored.
@@ -25,9 +31,9 @@
*/
#define MEM_NOSHUF32(NAME, ST_TYPE, LD_TYPE, ST_OP, LD_OP) \
-static inline unsigned int NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
+static inline uint32_t NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
{ \
- unsigned int ret; \
+ uint32_t ret; \
asm volatile("{\n\t" \
" " #ST_OP "(%1) = %3\n\t" \
" %0 = " #LD_OP "(%2)\n\t" \
@@ -39,9 +45,9 @@ static inline unsigned int NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
}
#define MEM_NOSHUF64(NAME, ST_TYPE, LD_TYPE, ST_OP, LD_OP) \
-static inline unsigned long long NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
+static inline uint64_t NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
{ \
- unsigned long long ret; \
+ uint64_t ret; \
asm volatile("{\n\t" \
" " #ST_OP "(%1) = %3\n\t" \
" %0 = " #LD_OP "(%2)\n\t" \
@@ -53,38 +59,39 @@ static inline unsigned long long NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
}
/* Store byte combinations */
-MEM_NOSHUF32(mem_noshuf_sb_lb, signed char, signed char, memb, memb)
-MEM_NOSHUF32(mem_noshuf_sb_lub, signed char, unsigned char, memb, memub)
-MEM_NOSHUF32(mem_noshuf_sb_lh, signed char, signed short, memb, memh)
-MEM_NOSHUF32(mem_noshuf_sb_luh, signed char, unsigned short, memb, memuh)
-MEM_NOSHUF32(mem_noshuf_sb_lw, signed char, signed int, memb, memw)
-MEM_NOSHUF64(mem_noshuf_sb_ld, signed char, signed long long, memb, memd)
+MEM_NOSHUF32(mem_noshuf_sb_lb, int8_t, int8_t, memb, memb)
+MEM_NOSHUF32(mem_noshuf_sb_lub, int8_t, uint8_t, memb, memub)
+MEM_NOSHUF32(mem_noshuf_sb_lh, int8_t, int16_t, memb, memh)
+MEM_NOSHUF32(mem_noshuf_sb_luh, int8_t, uint16_t, memb, memuh)
+MEM_NOSHUF32(mem_noshuf_sb_lw, int8_t, int32_t, memb, memw)
+MEM_NOSHUF64(mem_noshuf_sb_ld, int8_t, int64_t, memb, memd)
/* Store half combinations */
-MEM_NOSHUF32(mem_noshuf_sh_lb, signed short, signed char, memh, memb)
-MEM_NOSHUF32(mem_noshuf_sh_lub, signed short, unsigned char, memh, memub)
-MEM_NOSHUF32(mem_noshuf_sh_lh, signed short, signed short, memh, memh)
-MEM_NOSHUF32(mem_noshuf_sh_luh, signed short, unsigned short, memh, memuh)
-MEM_NOSHUF32(mem_noshuf_sh_lw, signed short, signed int, memh, memw)
-MEM_NOSHUF64(mem_noshuf_sh_ld, signed short, signed long long, memh, memd)
+MEM_NOSHUF32(mem_noshuf_sh_lb, int16_t, int8_t, memh, memb)
+MEM_NOSHUF32(mem_noshuf_sh_lub, int16_t, uint8_t, memh, memub)
+MEM_NOSHUF32(mem_noshuf_sh_lh, int16_t, int16_t, memh, memh)
+MEM_NOSHUF32(mem_noshuf_sh_luh, int16_t, uint16_t, memh, memuh)
+MEM_NOSHUF32(mem_noshuf_sh_lw, int16_t, int32_t, memh, memw)
+MEM_NOSHUF64(mem_noshuf_sh_ld, int16_t, int64_t, memh, memd)
/* Store word combinations */
-MEM_NOSHUF32(mem_noshuf_sw_lb, signed int, signed char, memw, memb)
-MEM_NOSHUF32(mem_noshuf_sw_lub, signed int, unsigned char, memw, memub)
-MEM_NOSHUF32(mem_noshuf_sw_lh, signed int, signed short, memw, memh)
-MEM_NOSHUF32(mem_noshuf_sw_luh, signed int, unsigned short, memw, memuh)
-MEM_NOSHUF32(mem_noshuf_sw_lw, signed int, signed int, memw, memw)
-MEM_NOSHUF64(mem_noshuf_sw_ld, signed int, signed long long, memw, memd)
+MEM_NOSHUF32(mem_noshuf_sw_lb, int32_t, int8_t, memw, memb)
+MEM_NOSHUF32(mem_noshuf_sw_lub, int32_t, uint8_t, memw, memub)
+MEM_NOSHUF32(mem_noshuf_sw_lh, int32_t, int16_t, memw, memh)
+MEM_NOSHUF32(mem_noshuf_sw_luh, int32_t, uint16_t, memw, memuh)
+MEM_NOSHUF32(mem_noshuf_sw_lw, int32_t, int32_t, memw, memw)
+MEM_NOSHUF64(mem_noshuf_sw_ld, int32_t, int64_t, memw, memd)
/* Store double combinations */
-MEM_NOSHUF32(mem_noshuf_sd_lb, long long, signed char, memd, memb)
-MEM_NOSHUF32(mem_noshuf_sd_lub, long long, unsigned char, memd, memub)
-MEM_NOSHUF32(mem_noshuf_sd_lh, long long, signed short, memd, memh)
-MEM_NOSHUF32(mem_noshuf_sd_luh, long long, unsigned short, memd, memuh)
-MEM_NOSHUF32(mem_noshuf_sd_lw, long long, signed int, memd, memw)
-MEM_NOSHUF64(mem_noshuf_sd_ld, long long, signed long long, memd, memd)
-
-static inline int pred_lw_sw(int pred, int *p, int *q, int x, int y)
+MEM_NOSHUF32(mem_noshuf_sd_lb, int64_t, int8_t, memd, memb)
+MEM_NOSHUF32(mem_noshuf_sd_lub, int64_t, uint8_t, memd, memub)
+MEM_NOSHUF32(mem_noshuf_sd_lh, int64_t, int16_t, memd, memh)
+MEM_NOSHUF32(mem_noshuf_sd_luh, int64_t, uint16_t, memd, memuh)
+MEM_NOSHUF32(mem_noshuf_sd_lw, int64_t, int32_t, memd, memw)
+MEM_NOSHUF64(mem_noshuf_sd_ld, int64_t, int64_t, memd, memd)
+
+static inline int pred_lw_sw(bool pred, int32_t *p, int32_t *q,
+ int32_t x, int32_t y)
{
int ret;
asm volatile("p0 = cmp.eq(%5, #0)\n\t"
@@ -99,7 +106,8 @@ static inline int pred_lw_sw(int pred, int *p, int *q, int x, int y)
return ret;
}
-static inline int pred_lw_sw_pi(int pred, int *p, int *q, int x, int y)
+static inline int pred_lw_sw_pi(bool pred, int32_t *p, int32_t *q,
+ int32_t x, int32_t y)
{
int ret;
asm volatile("p0 = cmp.eq(%5, #0)\n\t"
@@ -115,10 +123,10 @@ static inline int pred_lw_sw_pi(int pred, int *p, int *q, int x, int y)
return ret;
}
-static inline long long pred_ld_sd(int pred, long long *p, long long *q,
- long long x, long long y)
+static inline int64_t pred_ld_sd(bool pred, int64_t *p, int64_t *q,
+ int64_t x, int64_t y)
{
- unsigned long long ret;
+ int64_t ret;
asm volatile("p0 = cmp.eq(%5, #0)\n\t"
"%0 = %3\n\t"
"{\n\t"
@@ -131,10 +139,10 @@ static inline long long pred_ld_sd(int pred, long long *p, long long *q,
return ret;
}
-static inline long long pred_ld_sd_pi(int pred, long long *p, long long *q,
- long long x, long long y)
+static inline int64_t pred_ld_sd_pi(bool pred, int64_t *p, int64_t *q,
+ int64_t x, int64_t y)
{
- long long ret;
+ int64_t ret;
asm volatile("p0 = cmp.eq(%5, #0)\n\t"
"%0 = %3\n\t"
"r7 = %2\n\t"
@@ -148,9 +156,9 @@ static inline long long pred_ld_sd_pi(int pred, long long *p, long long *q,
return ret;
}
-static inline unsigned int cancel_sw_lb(int pred, int *p, signed char *q, int x)
+static inline int32_t cancel_sw_lb(bool pred, int32_t *p, int8_t *q, int32_t x)
{
- unsigned int ret;
+ int32_t ret;
asm volatile("p0 = cmp.eq(%4, #0)\n\t"
"{\n\t"
" if (!p0) memw(%1) = %3\n\t"
@@ -162,10 +170,9 @@ static inline unsigned int cancel_sw_lb(int pred, int *p, signed char *q, int x)
return ret;
}
-static inline
-unsigned long long cancel_sw_ld(int pred, int *p, long long *q, int x)
+static inline int64_t cancel_sw_ld(bool pred, int32_t *p, int64_t *q, int32_t x)
{
- long long ret;
+ int64_t ret;
asm volatile("p0 = cmp.eq(%4, #0)\n\t"
"{\n\t"
" if (!p0) memw(%1) = %3\n\t"
@@ -178,43 +185,21 @@ unsigned long long cancel_sw_ld(int pred, int *p, long long *q, int x)
}
typedef union {
- signed long long d[2];
- unsigned long long ud[2];
- signed int w[4];
- unsigned int uw[4];
- signed short h[8];
- unsigned short uh[8];
- signed char b[16];
- unsigned char ub[16];
+ int64_t d[2];
+ uint64_t ud[2];
+ int32_t w[4];
+ uint32_t uw[4];
+ int16_t h[8];
+ uint16_t uh[8];
+ int8_t b[16];
+ uint8_t ub[16];
} Memory;
-int err;
-
-#define check32(n, expect) check32_(n, expect, __LINE__)
-
-static void check32_(int n, int expect, int line)
-{
- if (n != expect) {
- printf("ERROR: 0x%08x != 0x%08x, line %d\n", n, expect, line);
- err++;
- }
-}
-
-#define check64(n, expect) check64_(n, expect, __LINE__)
-
-static void check64_(long long n, long long expect, int line)
-{
- if (n != expect) {
- printf("ERROR: 0x%08llx != 0x%08llx, line %d\n", n, expect, line);
- err++;
- }
-}
-
int main()
{
Memory n;
- unsigned int res32;
- unsigned long long res64;
+ uint32_t res32;
+ uint64_t res64;
/*
* Store byte combinations
@@ -328,30 +313,30 @@ int main()
* Predicated word stores
*/
n.w[0] = ~0;
- res32 = cancel_sw_lb(0, &n.w[0], &n.b[0], 0x12345678);
+ res32 = cancel_sw_lb(false, &n.w[0], &n.b[0], 0x12345678);
check32(res32, 0xffffffff);
n.w[0] = ~0;
- res32 = cancel_sw_lb(1, &n.w[0], &n.b[0], 0x12345687);
+ res32 = cancel_sw_lb(true, &n.w[0], &n.b[0], 0x12345687);
check32(res32, 0xffffff87);
/*
* Predicated double stores
*/
n.d[0] = ~0LL;
- res64 = cancel_sw_ld(0, &n.w[0], &n.d[0], 0x12345678);
+ res64 = cancel_sw_ld(false, &n.w[0], &n.d[0], 0x12345678);
check64(res64, 0xffffffffffffffffLL);
n.d[0] = ~0LL;
- res64 = cancel_sw_ld(1, &n.w[0], &n.d[0], 0x12345678);
+ res64 = cancel_sw_ld(true, &n.w[0], &n.d[0], 0x12345678);
check64(res64, 0xffffffff12345678LL);
n.d[0] = ~0LL;
- res64 = cancel_sw_ld(0, &n.w[1], &n.d[0], 0x12345678);
+ res64 = cancel_sw_ld(false, &n.w[1], &n.d[0], 0x12345678);
check64(res64, 0xffffffffffffffffLL);
n.d[0] = ~0LL;
- res64 = cancel_sw_ld(1, &n.w[1], &n.d[0], 0x12345678);
+ res64 = cancel_sw_ld(true, &n.w[1], &n.d[0], 0x12345678);
check64(res64, 0x12345678ffffffffLL);
/*
@@ -392,45 +377,45 @@ int main()
check64(res64, 0xffffffffffffffffLL);
n.w[0] = ~0;
- res32 = pred_lw_sw(0, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
+ res32 = pred_lw_sw(false, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
check32(res32, 0x12345678);
check32(n.w[0], 0xc0ffeeda);
n.w[0] = ~0;
- res32 = pred_lw_sw(1, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
+ res32 = pred_lw_sw(true, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
check32(res32, 0xc0ffeeda);
check32(n.w[0], 0xc0ffeeda);
n.w[0] = ~0;
- res32 = pred_lw_sw_pi(0, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
+ res32 = pred_lw_sw_pi(false, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
check32(res32, 0x12345678);
check32(n.w[0], 0xc0ffeeda);
n.w[0] = ~0;
- res32 = pred_lw_sw_pi(1, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
+ res32 = pred_lw_sw_pi(true, &n.w[0], &n.w[0], 0x12345678, 0xc0ffeeda);
check32(res32, 0xc0ffeeda);
check32(n.w[0], 0xc0ffeeda);
n.d[0] = ~0LL;
- res64 = pred_ld_sd(0, &n.d[0], &n.d[0],
+ res64 = pred_ld_sd(false, &n.d[0], &n.d[0],
0x1234567812345678LL, 0xc0ffeedac0ffeedaLL);
check64(res64, 0x1234567812345678LL);
check64(n.d[0], 0xc0ffeedac0ffeedaLL);
n.d[0] = ~0LL;
- res64 = pred_ld_sd(1, &n.d[0], &n.d[0],
+ res64 = pred_ld_sd(true, &n.d[0], &n.d[0],
0x1234567812345678LL, 0xc0ffeedac0ffeedaLL);
check64(res64, 0xc0ffeedac0ffeedaLL);
check64(n.d[0], 0xc0ffeedac0ffeedaLL);
n.d[0] = ~0LL;
- res64 = pred_ld_sd_pi(0, &n.d[0], &n.d[0],
+ res64 = pred_ld_sd_pi(false, &n.d[0], &n.d[0],
0x1234567812345678LL, 0xc0ffeedac0ffeedaLL);
check64(res64, 0x1234567812345678LL);
check64(n.d[0], 0xc0ffeedac0ffeedaLL);
n.d[0] = ~0LL;
- res64 = pred_ld_sd_pi(1, &n.d[0], &n.d[0],
+ res64 = pred_ld_sd_pi(true, &n.d[0], &n.d[0],
0x1234567812345678LL, 0xc0ffeedac0ffeedaLL);
check64(res64, 0xc0ffeedac0ffeedaLL);
check64(n.d[0], 0xc0ffeedac0ffeedaLL);
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2022 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -34,6 +34,8 @@
#include <stdlib.h>
#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
@@ -41,49 +43,31 @@
#include <signal.h>
int err;
-int segv_caught;
-#define SHOULD_NOT_CHANGE_VAL 5
-int should_not_change = SHOULD_NOT_CHANGE_VAL;
-
-#define OK_TO_CHANGE_VAL 13
-int ok_to_change = OK_TO_CHANGE_VAL;
-
-static void __check(const char *filename, int line, int x, int expect)
-{
- if (x != expect) {
- printf("ERROR %s:%d - %d != %d\n",
- filename, line, x, expect);
- err++;
- }
-}
+#include "hex_test.h"
-#define check(x, expect) __check(__FILE__, __LINE__, (x), (expect))
+bool segv_caught;
-static void __chk_error(const char *filename, int line, int ret)
-{
- if (ret < 0) {
- printf("ERROR %s:%d - %d\n", filename, line, ret);
- err++;
- }
-}
+#define SHOULD_NOT_CHANGE_VAL 5
+int32_t should_not_change = SHOULD_NOT_CHANGE_VAL;
-#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))
+#define OK_TO_CHANGE_VAL 13
+int32_t ok_to_change = OK_TO_CHANGE_VAL;
jmp_buf jmp_env;
static void sig_segv(int sig, siginfo_t *info, void *puc)
{
- check(sig, SIGSEGV);
- segv_caught = 1;
+ check32(sig, SIGSEGV);
+ segv_caught = true;
longjmp(jmp_env, 1);
}
int main()
{
struct sigaction act;
- int dummy32;
- long long dummy64;
+ int32_t dummy32;
+ int64_t dummy64;
void *p;
/* SIGSEGV test */
@@ -106,8 +90,8 @@ int main()
act.sa_flags = 0;
chk_error(sigaction(SIGSEGV, &act, NULL));
- check(segv_caught, 1);
- check(should_not_change, SHOULD_NOT_CHANGE_VAL);
+ check32(segv_caught, true);
+ check32(should_not_change, SHOULD_NOT_CHANGE_VAL);
/*
* Check that a predicated load where the predicate is false doesn't
@@ -122,7 +106,7 @@ int main()
"}:mem_noshuf\n\t"
: "=r"(dummy32) : : "r18", "r19", "p0", "memory");
- check(ok_to_change, 7);
+ check32(ok_to_change, 7);
/*
* Also check that the post-increment doesn't happen when the
@@ -138,8 +122,8 @@ int main()
"}:mem_noshuf\n\t"
: "+r"(p), "=r"(dummy64) : : "r18", "p0", "memory");
- check(ok_to_change, 9);
- check((int)p, (int)NULL);
+ check32(ok_to_change, 9);
+ check32((int)p, (int)NULL);
puts(err ? "FAIL" : "PASS");
return err ? EXIT_FAILURE : EXIT_SUCCESS;
@@ -16,15 +16,15 @@
*/
#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
#include <string.h>
-#define CORE_HAS_CABAC (__HEXAGON_ARCH__ <= 71)
+int err;
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long uint64_t;
+#include "hex_test.h"
+#define CORE_HAS_CABAC (__HEXAGON_ARCH__ <= 71)
static inline void S4_storerhnew_rr(void *p, int index, uint16_t v)
{
@@ -76,7 +76,7 @@ static inline void *S4_storerinew_ap(uint32_t v)
return ret;
}
-static inline void S4_storeirbt_io(void *p, int pred)
+static inline void S4_storeirbt_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (p0) memb(%1+#4)=#27\n\t"
@@ -84,7 +84,7 @@ static inline void S4_storeirbt_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirbf_io(void *p, int pred)
+static inline void S4_storeirbf_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (!p0) memb(%1+#4)=#27\n\t"
@@ -92,7 +92,7 @@ static inline void S4_storeirbf_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirbtnew_io(void *p, int pred)
+static inline void S4_storeirbtnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -102,7 +102,7 @@ static inline void S4_storeirbtnew_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirbfnew_io(void *p, int pred)
+static inline void S4_storeirbfnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -112,7 +112,7 @@ static inline void S4_storeirbfnew_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirht_io(void *p, int pred)
+static inline void S4_storeirht_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (p0) memh(%1+#4)=#27\n\t"
@@ -120,7 +120,7 @@ static inline void S4_storeirht_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirhf_io(void *p, int pred)
+static inline void S4_storeirhf_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (!p0) memh(%1+#4)=#27\n\t"
@@ -128,7 +128,7 @@ static inline void S4_storeirhf_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirhtnew_io(void *p, int pred)
+static inline void S4_storeirhtnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -138,7 +138,7 @@ static inline void S4_storeirhtnew_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirhfnew_io(void *p, int pred)
+static inline void S4_storeirhfnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -148,7 +148,7 @@ static inline void S4_storeirhfnew_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirit_io(void *p, int pred)
+static inline void S4_storeirit_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (p0) memw(%1+#4)=#27\n\t"
@@ -156,7 +156,7 @@ static inline void S4_storeirit_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirif_io(void *p, int pred)
+static inline void S4_storeirif_io(void *p, bool pred)
{
asm volatile("p0 = cmp.eq(%0, #1)\n\t"
"if (!p0) memw(%1+#4)=#27\n\t"
@@ -164,7 +164,7 @@ static inline void S4_storeirif_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeiritnew_io(void *p, int pred)
+static inline void S4_storeiritnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -174,7 +174,7 @@ static inline void S4_storeiritnew_io(void *p, int pred)
: "p0", "memory");
}
-static inline void S4_storeirifnew_io(void *p, int pred)
+static inline void S4_storeirifnew_io(void *p, bool pred)
{
asm volatile("{\n\t"
" p0 = cmp.eq(%0, #1)\n\t"
@@ -184,9 +184,9 @@ static inline void S4_storeirifnew_io(void *p, int pred)
: "p0", "memory");
}
-static int L2_ploadrifnew_pi(void *p, int pred)
+static int32_t L2_ploadrifnew_pi(void *p, bool pred)
{
- int result;
+ int32_t result;
asm volatile("%0 = #31\n\t"
"{\n\t"
" p0 = cmp.eq(%2, #1)\n\t"
@@ -203,9 +203,9 @@ static int L2_ploadrifnew_pi(void *p, int pred)
* account for auto-anding. Then, we can do the predicated
* jump.
*/
-static inline int cmpnd_cmp_jump(void)
+static inline int32_t cmpnd_cmp_jump(void)
{
- int retval;
+ int32_t retval;
asm ("r5 = #7\n\t"
"r6 = #9\n\t"
"{\n\t"
@@ -222,9 +222,9 @@ static inline int cmpnd_cmp_jump(void)
return retval;
}
-static inline int test_clrtnew(int arg1, int old_val)
+static inline int32_t test_clrtnew(int32_t arg1, int32_t old_val)
{
- int ret;
+ int32_t ret;
asm volatile("r5 = %2\n\t"
"{\n\t"
"p0 = cmp.eq(%1, #1)\n\t"
@@ -237,36 +237,16 @@ static inline int test_clrtnew(int arg1, int old_val)
return ret;
}
-int err;
-
-static void check(int val, int expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%04x != 0x%04x\n", val, expect);
- err++;
- }
-}
-
-#if CORE_HAS_CABAC
-static void check64(long long val, long long expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%016llx != 0x%016llx\n", val, expect);
- err++;
- }
-}
-#endif
-
uint32_t init[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
uint32_t array[10];
-uint32_t early_exit;
+bool early_exit;
/*
* Write this as a function because we can't guarantee the compiler will
* allocate a frame with just the SL2_return_tnew packet.
*/
-static void SL2_return_tnew(int x);
+static void SL2_return_tnew(bool pred);
asm ("SL2_return_tnew:\n\t"
" allocframe(#0)\n\t"
" r1 = #1\n\t"
@@ -280,9 +260,9 @@ asm ("SL2_return_tnew:\n\t"
" dealloc_return\n\t"
);
-static long long creg_pair(int x, int y)
+static int64_t creg_pair(int32_t x, int32_t y)
{
- long long retval;
+ int64_t retval;
asm ("m0 = %1\n\t"
"m1 = %2\n\t"
"%0 = c7:6\n\t"
@@ -291,9 +271,9 @@ static long long creg_pair(int x, int y)
}
#if CORE_HAS_CABAC
-static long long decbin(long long x, long long y, int *pred)
+static int64_t decbin(int64_t x, int64_t y, bool *pred)
{
- long long retval;
+ int64_t retval;
asm ("%0 = decbin(%2, %3)\n\t"
"%1 = p0\n\t"
: "=r"(retval), "=r"(*pred)
@@ -303,9 +283,9 @@ static long long decbin(long long x, long long y, int *pred)
#endif
/* Check that predicates are auto-and'ed in a packet */
-static int auto_and(void)
+static bool auto_and(void)
{
- int retval;
+ bool retval;
asm ("r5 = #1\n\t"
"{\n\t"
" p0 = cmp.eq(r1, #1)\n\t"
@@ -320,7 +300,7 @@ static int auto_and(void)
void test_lsbnew(void)
{
- int result;
+ int32_t result;
asm("r0 = #2\n\t"
"r1 = #5\n\t"
@@ -330,7 +310,7 @@ void test_lsbnew(void)
"}\n\t"
"%0 = r1\n\t"
: "=r"(result) :: "r0", "r1", "p0");
- check(result, 5);
+ check32(result, 5);
}
void test_l2fetch(void)
@@ -340,226 +320,224 @@ void test_l2fetch(void)
"l2fetch(r0, r3:2)\n\t");
}
-static inline int ct0(uint32_t x)
+static inline int32_t ct0(uint32_t x)
{
- int res;
+ int32_t res;
asm("%0 = ct0(%1)\n\t" : "=r"(res) : "r"(x));
return res;
}
-static inline int ct1(uint32_t x)
+static inline int32_t ct1(uint32_t x)
{
- int res;
+ int32_t res;
asm("%0 = ct1(%1)\n\t" : "=r"(res) : "r"(x));
return res;
}
-static inline int ct0p(uint64_t x)
+static inline int32_t ct0p(uint64_t x)
{
- int res;
+ int32_t res;
asm("%0 = ct0(%1)\n\t" : "=r"(res) : "r"(x));
return res;
}
-static inline int ct1p(uint64_t x)
+static inline int32_t ct1p(uint64_t x)
{
- int res;
+ int32_t res;
asm("%0 = ct1(%1)\n\t" : "=r"(res) : "r"(x));
return res;
}
void test_count_trailing_zeros_ones(void)
{
- check(ct0(0x0000000f), 0);
- check(ct0(0x00000000), 32);
- check(ct0(0x000000f0), 4);
+ check32(ct0(0x0000000f), 0);
+ check32(ct0(0x00000000), 32);
+ check32(ct0(0x000000f0), 4);
- check(ct1(0x000000f0), 0);
- check(ct1(0x0000000f), 4);
- check(ct1(0x00000000), 0);
- check(ct1(0xffffffff), 32);
+ check32(ct1(0x000000f0), 0);
+ check32(ct1(0x0000000f), 4);
+ check32(ct1(0x00000000), 0);
+ check32(ct1(0xffffffff), 32);
- check(ct0p(0x000000000000000fULL), 0);
- check(ct0p(0x0000000000000000ULL), 64);
- check(ct0p(0x00000000000000f0ULL), 4);
+ check32(ct0p(0x000000000000000fULL), 0);
+ check32(ct0p(0x0000000000000000ULL), 64);
+ check32(ct0p(0x00000000000000f0ULL), 4);
- check(ct1p(0x00000000000000f0ULL), 0);
- check(ct1p(0x000000000000000fULL), 4);
- check(ct1p(0x0000000000000000ULL), 0);
- check(ct1p(0xffffffffffffffffULL), 64);
- check(ct1p(0xffffffffff0fffffULL), 20);
- check(ct1p(0xffffff0fffffffffULL), 36);
+ check32(ct1p(0x00000000000000f0ULL), 0);
+ check32(ct1p(0x000000000000000fULL), 4);
+ check32(ct1p(0x0000000000000000ULL), 0);
+ check32(ct1p(0xffffffffffffffffULL), 64);
+ check32(ct1p(0xffffffffff0fffffULL), 20);
+ check32(ct1p(0xffffff0fffffffffULL), 36);
}
-static inline int dpmpyss_rnd_s0(int x, int y)
+static inline int32_t dpmpyss_rnd_s0(int32_t x, int32_t y)
{
- int res;
+ int32_t res;
asm("%0 = mpy(%1, %2):rnd\n\t" : "=r"(res) : "r"(x), "r"(y));
return res;
}
void test_dpmpyss_rnd_s0(void)
{
- check(dpmpyss_rnd_s0(-1, 0x80000000), 1);
- check(dpmpyss_rnd_s0(0, 0x80000000), 0);
- check(dpmpyss_rnd_s0(1, 0x80000000), 0);
- check(dpmpyss_rnd_s0(0x7fffffff, 0x80000000), 0xc0000001);
- check(dpmpyss_rnd_s0(0x80000000, -1), 1);
- check(dpmpyss_rnd_s0(-1, -1), 0);
- check(dpmpyss_rnd_s0(0, -1), 0);
- check(dpmpyss_rnd_s0(1, -1), 0);
- check(dpmpyss_rnd_s0(0x7fffffff, -1), 0);
- check(dpmpyss_rnd_s0(0x80000000, 0), 0);
- check(dpmpyss_rnd_s0(-1, 0), 0);
- check(dpmpyss_rnd_s0(0, 0), 0);
- check(dpmpyss_rnd_s0(1, 0), 0);
- check(dpmpyss_rnd_s0(-1, -1), 0);
- check(dpmpyss_rnd_s0(0, -1), 0);
- check(dpmpyss_rnd_s0(1, -1), 0);
- check(dpmpyss_rnd_s0(0x7fffffff, 1), 0);
- check(dpmpyss_rnd_s0(0x80000000, 0x7fffffff), 0xc0000001);
- check(dpmpyss_rnd_s0(-1, 0x7fffffff), 0);
- check(dpmpyss_rnd_s0(0, 0x7fffffff), 0);
- check(dpmpyss_rnd_s0(1, 0x7fffffff), 0);
- check(dpmpyss_rnd_s0(0x7fffffff, 0x7fffffff), 0x3fffffff);
+ check32(dpmpyss_rnd_s0(-1, 0x80000000), 1);
+ check32(dpmpyss_rnd_s0(0, 0x80000000), 0);
+ check32(dpmpyss_rnd_s0(1, 0x80000000), 0);
+ check32(dpmpyss_rnd_s0(0x7fffffff, 0x80000000), 0xc0000001);
+ check32(dpmpyss_rnd_s0(0x80000000, -1), 1);
+ check32(dpmpyss_rnd_s0(-1, -1), 0);
+ check32(dpmpyss_rnd_s0(0, -1), 0);
+ check32(dpmpyss_rnd_s0(1, -1), 0);
+ check32(dpmpyss_rnd_s0(0x7fffffff, -1), 0);
+ check32(dpmpyss_rnd_s0(0x80000000, 0), 0);
+ check32(dpmpyss_rnd_s0(-1, 0), 0);
+ check32(dpmpyss_rnd_s0(0, 0), 0);
+ check32(dpmpyss_rnd_s0(1, 0), 0);
+ check32(dpmpyss_rnd_s0(-1, -1), 0);
+ check32(dpmpyss_rnd_s0(0, -1), 0);
+ check32(dpmpyss_rnd_s0(1, -1), 0);
+ check32(dpmpyss_rnd_s0(0x7fffffff, 1), 0);
+ check32(dpmpyss_rnd_s0(0x80000000, 0x7fffffff), 0xc0000001);
+ check32(dpmpyss_rnd_s0(-1, 0x7fffffff), 0);
+ check32(dpmpyss_rnd_s0(0, 0x7fffffff), 0);
+ check32(dpmpyss_rnd_s0(1, 0x7fffffff), 0);
+ check32(dpmpyss_rnd_s0(0x7fffffff, 0x7fffffff), 0x3fffffff);
}
int main()
{
- int res;
-#if CORE_HAS_CABAC
- long long res64;
- int pred;
-#endif
+ int32_t res;
+ int64_t res64;
+ bool pred;
memcpy(array, init, sizeof(array));
S4_storerhnew_rr(array, 4, 0xffff);
- check(array[4], 0xffff);
+ check32(array[4], 0xffff);
data = ~0;
- check((uint32_t)S4_storerbnew_ap(0x12), (uint32_t)&data);
- check(data, 0xffffff12);
+ checkp(S4_storerbnew_ap(0x12), &data);
+ check32(data, 0xffffff12);
data = ~0;
- check((uint32_t)S4_storerhnew_ap(0x1234), (uint32_t)&data);
- check(data, 0xffff1234);
+ checkp(S4_storerhnew_ap(0x1234), &data);
+ check32(data, 0xffff1234);
data = ~0;
- check((uint32_t)S4_storerinew_ap(0x12345678), (uint32_t)&data);
- check(data, 0x12345678);
+ checkp(S4_storerinew_ap(0x12345678), &data);
+ check32(data, 0x12345678);
/* Byte */
memcpy(array, init, sizeof(array));
- S4_storeirbt_io(&array[1], 1);
- check(array[2], 27);
- S4_storeirbt_io(&array[2], 0);
- check(array[3], 3);
+ S4_storeirbt_io(&array[1], true);
+ check32(array[2], 27);
+ S4_storeirbt_io(&array[2], false);
+ check32(array[3], 3);
memcpy(array, init, sizeof(array));
- S4_storeirbf_io(&array[3], 0);
- check(array[4], 27);
- S4_storeirbf_io(&array[4], 1);
- check(array[5], 5);
+ S4_storeirbf_io(&array[3], false);
+ check32(array[4], 27);
+ S4_storeirbf_io(&array[4], true);
+ check32(array[5], 5);
memcpy(array, init, sizeof(array));
- S4_storeirbtnew_io(&array[5], 1);
- check(array[6], 27);
- S4_storeirbtnew_io(&array[6], 0);
- check(array[7], 7);
+ S4_storeirbtnew_io(&array[5], true);
+ check32(array[6], 27);
+ S4_storeirbtnew_io(&array[6], false);
+ check32(array[7], 7);
memcpy(array, init, sizeof(array));
- S4_storeirbfnew_io(&array[7], 0);
- check(array[8], 27);
- S4_storeirbfnew_io(&array[8], 1);
- check(array[9], 9);
+ S4_storeirbfnew_io(&array[7], false);
+ check32(array[8], 27);
+ S4_storeirbfnew_io(&array[8], true);
+ check32(array[9], 9);
/* Half word */
memcpy(array, init, sizeof(array));
- S4_storeirht_io(&array[1], 1);
- check(array[2], 27);
- S4_storeirht_io(&array[2], 0);
- check(array[3], 3);
+ S4_storeirht_io(&array[1], true);
+ check32(array[2], 27);
+ S4_storeirht_io(&array[2], false);
+ check32(array[3], 3);
memcpy(array, init, sizeof(array));
- S4_storeirhf_io(&array[3], 0);
- check(array[4], 27);
- S4_storeirhf_io(&array[4], 1);
- check(array[5], 5);
+ S4_storeirhf_io(&array[3], false);
+ check32(array[4], 27);
+ S4_storeirhf_io(&array[4], true);
+ check32(array[5], 5);
memcpy(array, init, sizeof(array));
- S4_storeirhtnew_io(&array[5], 1);
- check(array[6], 27);
- S4_storeirhtnew_io(&array[6], 0);
- check(array[7], 7);
+ S4_storeirhtnew_io(&array[5], true);
+ check32(array[6], 27);
+ S4_storeirhtnew_io(&array[6], false);
+ check32(array[7], 7);
memcpy(array, init, sizeof(array));
- S4_storeirhfnew_io(&array[7], 0);
- check(array[8], 27);
- S4_storeirhfnew_io(&array[8], 1);
- check(array[9], 9);
+ S4_storeirhfnew_io(&array[7], false);
+ check32(array[8], 27);
+ S4_storeirhfnew_io(&array[8], true);
+ check32(array[9], 9);
/* Word */
memcpy(array, init, sizeof(array));
- S4_storeirit_io(&array[1], 1);
- check(array[2], 27);
- S4_storeirit_io(&array[2], 0);
- check(array[3], 3);
+ S4_storeirit_io(&array[1], true);
+ check32(array[2], 27);
+ S4_storeirit_io(&array[2], false);
+ check32(array[3], 3);
memcpy(array, init, sizeof(array));
- S4_storeirif_io(&array[3], 0);
- check(array[4], 27);
- S4_storeirif_io(&array[4], 1);
- check(array[5], 5);
+ S4_storeirif_io(&array[3], false);
+ check32(array[4], 27);
+ S4_storeirif_io(&array[4], true);
+ check32(array[5], 5);
memcpy(array, init, sizeof(array));
- S4_storeiritnew_io(&array[5], 1);
- check(array[6], 27);
- S4_storeiritnew_io(&array[6], 0);
- check(array[7], 7);
+ S4_storeiritnew_io(&array[5], true);
+ check32(array[6], 27);
+ S4_storeiritnew_io(&array[6], false);
+ check32(array[7], 7);
memcpy(array, init, sizeof(array));
- S4_storeirifnew_io(&array[7], 0);
- check(array[8], 27);
- S4_storeirifnew_io(&array[8], 1);
- check(array[9], 9);
+ S4_storeirifnew_io(&array[7], false);
+ check32(array[8], 27);
+ S4_storeirifnew_io(&array[8], true);
+ check32(array[9], 9);
memcpy(array, init, sizeof(array));
- res = L2_ploadrifnew_pi(&array[6], 0);
- check(res, 6);
- res = L2_ploadrifnew_pi(&array[7], 1);
- check(res, 31);
+ res = L2_ploadrifnew_pi(&array[6], false);
+ check32(res, 6);
+ res = L2_ploadrifnew_pi(&array[7], true);
+ check32(res, 31);
- int x = cmpnd_cmp_jump();
- check(x, 12);
+ res = cmpnd_cmp_jump();
+ check32(res, 12);
- SL2_return_tnew(0);
- check(early_exit, 0);
- SL2_return_tnew(1);
- check(early_exit, 1);
+ SL2_return_tnew(false);
+ check32(early_exit, false);
+ SL2_return_tnew(true);
+ check32(early_exit, true);
- long long pair = creg_pair(5, 7);
- check((int)pair, 5);
- check((int)(pair >> 32), 7);
+ res64 = creg_pair(5, 7);
+ check32((int32_t)res64, 5);
+ check32((int32_t)(res64 >> 32), 7);
res = test_clrtnew(1, 7);
- check(res, 0);
+ check32(res, 0);
res = test_clrtnew(2, 7);
- check(res, 7);
+ check32(res, 7);
#if CORE_HAS_CABAC
res64 = decbin(0xf0f1f2f3f4f5f6f7LL, 0x7f6f5f4f3f2f1f0fLL, &pred);
check64(res64, 0x357980003700010cLL);
- check(pred, 0);
+ check32(pred, false);
res64 = decbin(0xfLL, 0x1bLL, &pred);
check64(res64, 0x78000100LL);
- check(pred, 1);
+ check32(pred, true);
#else
puts("Skipping cabac tests");
#endif
- res = auto_and();
- check(res, 0);
+ pred = auto_and();
+ check32(pred, false);
test_lsbnew();
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2019-2021 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,11 +16,17 @@
*/
#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
-static int sfrecipa(int Rs, int Rt, int *pred_result)
+int err;
+
+#include "hex_test.h"
+
+static int32_t sfrecipa(int32_t Rs, int32_t Rt, bool *pred_result)
{
- int result;
- int predval;
+ int32_t result;
+ bool predval;
asm volatile("%0,p0 = sfrecipa(%2, %3)\n\t"
"%1 = p0\n\t"
@@ -31,10 +37,10 @@ static int sfrecipa(int Rs, int Rt, int *pred_result)
return result;
}
-static int sfinvsqrta(int Rs, int *pred_result)
+static int32_t sfinvsqrta(int32_t Rs, int32_t *pred_result)
{
- int result;
- int predval;
+ int32_t result;
+ int32_t predval;
asm volatile("%0,p0 = sfinvsqrta(%2)\n\t"
"%1 = p0\n\t"
@@ -45,12 +51,12 @@ static int sfinvsqrta(int Rs, int *pred_result)
return result;
}
-static long long vacsh(long long Rxx, long long Rss, long long Rtt,
- int *pred_result, int *ovf_result)
+static int64_t vacsh(int64_t Rxx, int64_t Rss, int64_t Rtt,
+ int *pred_result, bool *ovf_result)
{
- long long result = Rxx;
+ int64_t result = Rxx;
int predval;
- int usr;
+ uint32_t usr;
/*
* This instruction can set bit 0 (OVF/overflow) in usr
@@ -70,11 +76,10 @@ static long long vacsh(long long Rxx, long long Rss, long long Rtt,
return result;
}
-static long long vminub(long long Rtt, long long Rss,
- int *pred_result)
+static int64_t vminub(int64_t Rtt, int64_t Rss, int32_t *pred_result)
{
- long long result;
- int predval;
+ int64_t result;
+ int32_t predval;
asm volatile("%0,p0 = vminub(%2, %3)\n\t"
"%1 = p0\n\t"
@@ -85,11 +90,11 @@ static long long vminub(long long Rtt, long long Rss,
return result;
}
-static long long add_carry(long long Rss, long long Rtt,
- int pred_in, int *pred_result)
+static int64_t add_carry(int64_t Rss, int64_t Rtt,
+ int32_t pred_in, int32_t *pred_result)
{
- long long result;
- int predval = pred_in;
+ int64_t result;
+ int32_t predval = pred_in;
asm volatile("p0 = %1\n\t"
"%0 = add(%2, %3, p0):carry\n\t"
@@ -101,11 +106,11 @@ static long long add_carry(long long Rss, long long Rtt,
return result;
}
-static long long sub_carry(long long Rss, long long Rtt,
- int pred_in, int *pred_result)
+static int64_t sub_carry(int64_t Rss, int64_t Rtt,
+ int32_t pred_in, int32_t *pred_result)
{
- long long result;
- int predval = pred_in;
+ int64_t result;
+ int32_t predval = pred_in;
asm volatile("p0 = !cmp.eq(%1, #0)\n\t"
"%0 = sub(%2, %3, p0):carry\n\t"
@@ -117,155 +122,129 @@ static long long sub_carry(long long Rss, long long Rtt,
return result;
}
-int err;
-
-static void check_ll(long long val, long long expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%016llx != 0x%016llx\n", val, expect);
- err++;
- }
-}
-
-static void check(int val, int expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%08x != 0x%08x\n", val, expect);
- err++;
- }
-}
-
-static void check_p(int val, int expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%02x != 0x%02x\n", val, expect);
- err++;
- }
-}
-
static void test_sfrecipa()
{
- int res;
- int pred_result;
+ int32_t res;
+ bool pred_result;
res = sfrecipa(0x04030201, 0x05060708, &pred_result);
- check(res, 0x59f38001);
- check_p(pred_result, 0x00);
+ check32(res, 0x59f38001);
+ check32(pred_result, false);
}
static void test_sfinvsqrta()
{
- int res;
- int pred_result;
+ int32_t res;
+ int32_t pred_result;
res = sfinvsqrta(0x04030201, &pred_result);
- check(res, 0x4d330000);
- check_p(pred_result, 0xe0);
+ check32(res, 0x4d330000);
+ check32(pred_result, 0xe0);
res = sfinvsqrta(0x0, &pred_result);
- check(res, 0x3f800000);
- check_p(pred_result, 0x0);
+ check32(res, 0x3f800000);
+ check32(pred_result, 0x0);
}
static void test_vacsh()
{
- long long res64;
- int pred_result;
- int ovf_result;
+ int64_t res64;
+ int32_t pred_result;
+ bool ovf_result;
res64 = vacsh(0x0004000300020001LL,
0x0001000200030004LL,
0x0000000000000000LL, &pred_result, &ovf_result);
- check_ll(res64, 0x0004000300030004LL);
- check_p(pred_result, 0xf0);
- check(ovf_result, 0);
+ check64(res64, 0x0004000300030004LL);
+ check32(pred_result, 0xf0);
+ check32(ovf_result, false);
res64 = vacsh(0x0004000300020001LL,
0x0001000200030004LL,
0x000affff000d0000LL, &pred_result, &ovf_result);
- check_ll(res64, 0x000e0003000f0004LL);
- check_p(pred_result, 0xcc);
- check(ovf_result, 0);
+ check64(res64, 0x000e0003000f0004LL);
+ check32(pred_result, 0xcc);
+ check32(ovf_result, false);
res64 = vacsh(0x00047fff00020001LL,
0x00017fff00030004LL,
0x000a0fff000d0000LL, &pred_result, &ovf_result);
- check_ll(res64, 0x000e7fff000f0004LL);
- check_p(pred_result, 0xfc);
- check(ovf_result, 1);
+ check64(res64, 0x000e7fff000f0004LL);
+ check32(pred_result, 0xfc);
+ check32(ovf_result, true);
res64 = vacsh(0x0004000300020001LL,
0x0001000200030009LL,
0x000affff000d0001LL, &pred_result, &ovf_result);
- check_ll(res64, 0x000e0003000f0008LL);
- check_p(pred_result, 0xcc);
- check(ovf_result, 0);
+ check64(res64, 0x000e0003000f0008LL);
+ check32(pred_result, 0xcc);
+ check32(ovf_result, false);
}
static void test_vminub()
{
- long long res64;
- int pred_result;
+ int64_t res64;
+ int32_t pred_result;
res64 = vminub(0x0807060504030201LL,
0x0102030405060708LL,
&pred_result);
- check_ll(res64, 0x0102030404030201LL);
- check_p(pred_result, 0xf0);
+ check64(res64, 0x0102030404030201LL);
+ check32(pred_result, 0xf0);
res64 = vminub(0x0802060405030701LL,
0x0107030504060208LL,
&pred_result);
- check_ll(res64, 0x0102030404030201LL);
- check_p(pred_result, 0xaa);
+ check64(res64, 0x0102030404030201LL);
+ check32(pred_result, 0xaa);
}
static void test_add_carry()
{
- long long res64;
- int pred_result;
+ int64_t res64;
+ int32_t pred_result;
res64 = add_carry(0x0000000000000000LL,
0xffffffffffffffffLL,
1, &pred_result);
- check_ll(res64, 0x0000000000000000LL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x0000000000000000LL);
+ check32(pred_result, 0xff);
res64 = add_carry(0x0000000100000000LL,
0xffffffffffffffffLL,
0, &pred_result);
- check_ll(res64, 0x00000000ffffffffLL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x00000000ffffffffLL);
+ check32(pred_result, 0xff);
res64 = add_carry(0x0000000100000000LL,
0xffffffffffffffffLL,
0, &pred_result);
- check_ll(res64, 0x00000000ffffffffLL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x00000000ffffffffLL);
+ check32(pred_result, 0xff);
}
static void test_sub_carry()
{
- long long res64;
- int pred_result;
+ int64_t res64;
+ int32_t pred_result;
res64 = sub_carry(0x0000000000000000LL,
0x0000000000000000LL,
1, &pred_result);
- check_ll(res64, 0x0000000000000000LL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x0000000000000000LL);
+ check32(pred_result, 0xff);
res64 = sub_carry(0x0000000100000000LL,
0x0000000000000000LL,
0, &pred_result);
- check_ll(res64, 0x00000000ffffffffLL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x00000000ffffffffLL);
+ check32(pred_result, 0xff);
res64 = sub_carry(0x0000000100000000LL,
0x0000000000000000LL,
0, &pred_result);
- check_ll(res64, 0x00000000ffffffffLL);
- check_p(pred_result, 0xff);
+ check64(res64, 0x00000000ffffffffLL);
+ check32(pred_result, 0xff);
}
int main()
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2021-2022 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2021-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -17,30 +17,21 @@
#include <stdlib.h>
#include <stdio.h>
+#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <setjmp.h>
#include <signal.h>
-
int err;
-static void __check(const char *filename, int line, int x, int expect)
-{
- if (x != expect) {
- printf("ERROR %s:%d - %d != %d\n",
- filename, line, x, expect);
- err++;
- }
-}
-
-#define check(x, expect) __check(__FILE__, __LINE__, (x), (expect))
+#include "hex_test.h"
-static int satub(int src, int *p, int *ovf_result)
+static int32_t satub(int32_t src, int32_t *p, bool *ovf_result)
{
- int result;
- int usr;
+ int32_t result;
+ uint32_t usr;
/*
* This instruction can set bit 0 (OVF/overflow) in usr
@@ -65,30 +56,30 @@ static int satub(int src, int *p, int *ovf_result)
return result;
}
-int read_usr_overflow(void)
+bool read_usr_overflow(void)
{
- int result;
- asm volatile("%0 = usr\n\t" : "=r"(result));
- return result & 1;
+ uint32_t usr;
+ asm volatile("%0 = usr\n\t" : "=r"(usr));
+ return usr & 1;
}
-int get_usr_overflow(int usr)
+bool get_usr_overflow(uint32_t usr)
{
return usr & 1;
}
-int get_usr_fp_invalid(int usr)
+bool get_usr_fp_invalid(uint32_t usr)
{
return (usr >> 1) & 1;
}
-int get_usr_lpcfg(int usr)
+int32_t get_usr_lpcfg(uint32_t usr)
{
return (usr >> 8) & 0x3;
}
jmp_buf jmp_env;
-int usr_overflow;
+bool usr_overflow;
static void sig_segv(int sig, siginfo_t *info, void *puc)
{
@@ -98,9 +89,9 @@ static void sig_segv(int sig, siginfo_t *info, void *puc)
static void test_packet(void)
{
- int convres;
- int satres;
- int usr;
+ int32_t convres;
+ int32_t satres;
+ uint32_t usr;
asm("r2 = usr\n\t"
"r2 = clrbit(r2, #0)\n\t" /* clear overflow bit */
@@ -115,10 +106,10 @@ static void test_packet(void)
: "r"(0x6a051b86), "r"(0x0410eec0)
: "r2", "usr");
- check(convres, 0xffffffff);
- check(satres, 0x7f);
- check(get_usr_overflow(usr), 1);
- check(get_usr_fp_invalid(usr), 1);
+ check32(convres, 0xffffffff);
+ check32(satres, 0x7f);
+ check32(get_usr_overflow(usr), true);
+ check32(get_usr_fp_invalid(usr), true);
asm("r2 = usr\n\t"
"r2 = clrbit(r2, #0)\n\t" /* clear overflow bit */
@@ -134,15 +125,15 @@ static void test_packet(void)
: "r"(0x0410eec0)
: "r2", "usr", "p3", "sa0", "lc0");
- check(satres, 0x7f);
- check(get_usr_overflow(usr), 1);
- check(get_usr_lpcfg(usr), 2);
+ check32(satres, 0x7f);
+ check32(get_usr_overflow(usr), true);
+ check32(get_usr_lpcfg(usr), 2);
}
int main()
{
struct sigaction act;
- int ovf;
+ bool ovf;
/* SIGSEGV test */
act.sa_sigaction = sig_segv;
@@ -157,7 +148,7 @@ int main()
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
- check(usr_overflow, 0);
+ check32(usr_overflow, false);
test_packet();
@@ -16,10 +16,15 @@
*/
#include <stdio.h>
+#include <stdint.h>
-static inline int preg_alias(int v0, int v1, int v2, int v3)
+int err;
+
+#include "hex_test.h"
+
+static uint32_t preg_alias(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3)
{
- int ret;
+ uint32_t ret;
asm volatile("p0 = %1\n\t"
"p1 = %2\n\t"
"p2 = %3\n\t"
@@ -31,9 +36,9 @@ static inline int preg_alias(int v0, int v1, int v2, int v3)
return ret;
}
-static inline int preg_alias_pair(int v0, int v1, int v2, int v3)
+static uint32_t preg_alias_pair(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3)
{
- long long c54;
+ uint64_t c54;
asm volatile("p0 = %1\n\t"
"p1 = %2\n\t"
"p2 = %3\n\t"
@@ -42,20 +47,20 @@ static inline int preg_alias_pair(int v0, int v1, int v2, int v3)
: "=r"(c54)
: "r"(v0), "r"(v1), "r"(v2), "r"(v3)
: "p0", "p1", "p2", "p3");
- return (int)c54;
+ return (uint32_t)c54;
}
typedef union {
- int creg;
+ uint32_t creg;
struct {
- unsigned char p0;
- unsigned char p1;
- unsigned char p2;
- unsigned char p3;
+ uint8_t p0;
+ uint8_t p1;
+ uint8_t p2;
+ uint8_t p3;
} pregs;
} PRegs;
-static inline void creg_alias(int cval, PRegs *pregs)
+static inline void creg_alias(uint32_t cval, PRegs *pregs)
{
asm("c4 = %4\n\t"
"%0 = p0\n\t"
@@ -68,20 +73,10 @@ static inline void creg_alias(int cval, PRegs *pregs)
: "c4", "p0", "p1", "p2", "p3");
}
-int err;
-
-static void check(int val, int expect)
-{
- if (val != expect) {
- printf("ERROR: 0x%08x != 0x%08x\n", val, expect);
- err++;
- }
-}
-
-static inline void creg_alias_pair(unsigned int cval, PRegs *pregs)
+static inline void creg_alias_pair(uint32_t cval, PRegs *pregs)
{
- unsigned long long cval_pair = (0xdeadbeefULL << 32) | cval;
- int c5;
+ uint64_t cval_pair = (0xdeadbeefULL << 32) | cval;
+ uint32_t c5;
asm ("c5:4 = %5\n\t"
"%0 = p0\n\t"
@@ -94,7 +89,7 @@ static inline void creg_alias_pair(unsigned int cval, PRegs *pregs)
: "r"(cval_pair)
: "c4", "c5", "p0", "p1", "p2", "p3");
- check(c5, 0xdeadbeef);
+ check32(c5, 0xdeadbeef);
}
static void test_packet(void)
@@ -104,8 +99,8 @@ static void test_packet(void)
* that are read during the packet.
*/
- int result;
- int old_val = 0x0000001c;
+ uint32_t result;
+ uint32_t old_val = 0x0000001c;
/* Test a predicated register transfer */
result = old_val;
@@ -118,7 +113,7 @@ static void test_packet(void)
: "+r"(result)
: "r"(0xffffffff), "r"(0xff00ffff), "r"(0x837ed653)
: "c4", "p0", "p1", "p2", "p3");
- check(result, old_val);
+ check32(result, old_val);
/* Test a predicated store */
result = 0xffffffff;
@@ -130,73 +125,73 @@ static void test_packet(void)
:
: "r"(0), "r"(0xffffffff), "r"(&result)
: "c4", "p0", "p1", "p2", "p3", "memory");
- check(result, 0x0);
+ check32(result, 0x0);
}
int main()
{
- int c4;
+ uint32_t c4;
PRegs pregs;
c4 = preg_alias(0xff, 0x00, 0xff, 0x00);
- check(c4, 0x00ff00ff);
+ check32(c4, 0x00ff00ff);
c4 = preg_alias(0xff, 0x00, 0x00, 0x00);
- check(c4, 0x000000ff);
+ check32(c4, 0x000000ff);
c4 = preg_alias(0x00, 0xff, 0x00, 0x00);
- check(c4, 0x0000ff00);
+ check32(c4, 0x0000ff00);
c4 = preg_alias(0x00, 0x00, 0xff, 0x00);
- check(c4, 0x00ff0000);
+ check32(c4, 0x00ff0000);
c4 = preg_alias(0x00, 0x00, 0x00, 0xff);
- check(c4, 0xff000000);
+ check32(c4, 0xff000000);
c4 = preg_alias(0xff, 0xff, 0xff, 0xff);
- check(c4, 0xffffffff);
+ check32(c4, 0xffffffff);
c4 = preg_alias_pair(0xff, 0x00, 0xff, 0x00);
- check(c4, 0x00ff00ff);
+ check32(c4, 0x00ff00ff);
c4 = preg_alias_pair(0xff, 0x00, 0x00, 0x00);
- check(c4, 0x000000ff);
+ check32(c4, 0x000000ff);
c4 = preg_alias_pair(0x00, 0xff, 0x00, 0x00);
- check(c4, 0x0000ff00);
+ check32(c4, 0x0000ff00);
c4 = preg_alias_pair(0x00, 0x00, 0xff, 0x00);
- check(c4, 0x00ff0000);
+ check32(c4, 0x00ff0000);
c4 = preg_alias_pair(0x00, 0x00, 0x00, 0xff);
- check(c4, 0xff000000);
+ check32(c4, 0xff000000);
c4 = preg_alias_pair(0xff, 0xff, 0xff, 0xff);
- check(c4, 0xffffffff);
+ check32(c4, 0xffffffff);
creg_alias(0x00ff00ff, &pregs);
- check(pregs.creg, 0x00ff00ff);
+ check32(pregs.creg, 0x00ff00ff);
creg_alias(0x00ffff00, &pregs);
- check(pregs.creg, 0x00ffff00);
+ check32(pregs.creg, 0x00ffff00);
creg_alias(0x00000000, &pregs);
- check(pregs.creg, 0x00000000);
+ check32(pregs.creg, 0x00000000);
creg_alias(0xff000000, &pregs);
- check(pregs.creg, 0xff000000);
+ check32(pregs.creg, 0xff000000);
creg_alias(0x00ff0000, &pregs);
- check(pregs.creg, 0x00ff0000);
+ check32(pregs.creg, 0x00ff0000);
creg_alias(0x0000ff00, &pregs);
- check(pregs.creg, 0x0000ff00);
+ check32(pregs.creg, 0x0000ff00);
creg_alias(0x000000ff, &pregs);
- check(pregs.creg, 0x000000ff);
+ check32(pregs.creg, 0x000000ff);
creg_alias(0xffffffff, &pregs);
- check(pregs.creg, 0xffffffff);
+ check32(pregs.creg, 0xffffffff);
creg_alias_pair(0x00ff00ff, &pregs);
- check(pregs.creg, 0x00ff00ff);
+ check32(pregs.creg, 0x00ff00ff);
creg_alias_pair(0x00ffff00, &pregs);
- check(pregs.creg, 0x00ffff00);
+ check32(pregs.creg, 0x00ffff00);
creg_alias_pair(0x00000000, &pregs);
- check(pregs.creg, 0x00000000);
+ check32(pregs.creg, 0x00000000);
creg_alias_pair(0xff000000, &pregs);
- check(pregs.creg, 0xff000000);
+ check32(pregs.creg, 0xff000000);
creg_alias_pair(0x00ff0000, &pregs);
- check(pregs.creg, 0x00ff0000);
+ check32(pregs.creg, 0x00ff0000);
creg_alias_pair(0x0000ff00, &pregs);
- check(pregs.creg, 0x0000ff00);
+ check32(pregs.creg, 0x0000ff00);
creg_alias_pair(0x000000ff, &pregs);
- check(pregs.creg, 0x000000ff);
+ check32(pregs.creg, 0x000000ff);
creg_alias_pair(0xffffffff, &pregs);
- check(pregs.creg, 0xffffffff);
+ check32(pregs.creg, 0xffffffff);
test_packet();
@@ -32,16 +32,7 @@
int err;
-static void __check(const char *filename, int line, int x, int expect)
-{
- if (x != expect) {
- printf("ERROR %s:%d - 0x%08x != 0x%08x\n",
- filename, line, x, expect);
- err++;
- }
-}
-
-#define check(x, expect) __check(__FILE__, __LINE__, (x), (expect))
+#include "hex_test.h"
#define insert(RES, X, WIDTH, OFFSET) \
asm("r7 = %1\n\t" \
@@ -54,11 +45,11 @@ static void test_insert(void)
uint32_t res;
insert(res, 0x12345678, 8, 1);
- check(res, 0x123456f0);
+ check32(res, 0x123456f0);
insert(res, 0x12345678, 0, 1);
- check(res, 0x12345678);
+ check32(res, 0x12345678);
insert(res, 0x12345678, 20, 16);
- check(res, 0x56785678);
+ check32(res, 0x56785678);
}
static inline uint32_t insert_rp(uint32_t x, uint32_t width, uint32_t offset)
@@ -75,12 +66,12 @@ static inline uint32_t insert_rp(uint32_t x, uint32_t width, uint32_t offset)
static void test_insert_rp(void)
{
- check(insert_rp(0x12345678, 8, 1), 0x123456f0);
- check(insert_rp(0x12345678, 63, 8), 0x34567878);
- check(insert_rp(0x12345678, 127, 8), 0x34567878);
- check(insert_rp(0x12345678, 8, 24), 0x78345678);
- check(insert_rp(0x12345678, 8, 63), 0x12345678);
- check(insert_rp(0x12345678, 8, 64), 0x00000000);
+ check32(insert_rp(0x12345678, 8, 1), 0x123456f0);
+ check32(insert_rp(0x12345678, 63, 8), 0x34567878);
+ check32(insert_rp(0x12345678, 127, 8), 0x34567878);
+ check32(insert_rp(0x12345678, 8, 24), 0x78345678);
+ check32(insert_rp(0x12345678, 8, 63), 0x12345678);
+ check32(insert_rp(0x12345678, 8, 64), 0x00000000);
}
static inline uint32_t asr_r_svw_trun(uint64_t x, uint32_t y)
@@ -95,18 +86,18 @@ static inline uint32_t asr_r_svw_trun(uint64_t x, uint32_t y)
static void test_asr_r_svw_trun(void)
{
- check(asr_r_svw_trun(0x1111111122222222ULL, 5),
- 0x88881111);
- check(asr_r_svw_trun(0x1111111122222222ULL, 63),
- 0x00000000);
- check(asr_r_svw_trun(0x1111111122222222ULL, 64),
- 0x00000000);
- check(asr_r_svw_trun(0x1111111122222222ULL, 127),
- 0x22224444);
- check(asr_r_svw_trun(0x1111111122222222ULL, 128),
- 0x11112222);
- check(asr_r_svw_trun(0xffffffff22222222ULL, 128),
- 0xffff2222);
+ check32(asr_r_svw_trun(0x1111111122222222ULL, 5),
+ 0x88881111);
+ check32(asr_r_svw_trun(0x1111111122222222ULL, 63),
+ 0x00000000);
+ check32(asr_r_svw_trun(0x1111111122222222ULL, 64),
+ 0x00000000);
+ check32(asr_r_svw_trun(0x1111111122222222ULL, 127),
+ 0x22224444);
+ check32(asr_r_svw_trun(0x1111111122222222ULL, 128),
+ 0x11112222);
+ check32(asr_r_svw_trun(0xffffffff22222222ULL, 128),
+ 0xffff2222);
}
static inline uint32_t swiz(uint32_t x)
@@ -121,7 +112,7 @@ static inline uint32_t swiz(uint32_t x)
static void test_swiz(void)
{
- check(swiz(0x11223344), 0x44332211);
+ check32(swiz(0x11223344), 0x44332211);
}
int main()
@@ -1,6 +1,6 @@
/*
- * Copyright(c) 2022 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -21,27 +21,7 @@
static int err;
-#define check(N, EXPECT) \
- do { \
- uint64_t value = N; \
- uint64_t expect = EXPECT; \
- if (value != EXPECT) { \
- printf("ERROR: \"%s\" 0x%04llx != 0x%04llx at %s:%d\n", #N, value, \
- expect, __FILE__, __LINE__); \
- err++; \
- } \
- } while (0)
-
-#define check_ne(N, EXPECT) \
- do { \
- uint64_t value = N; \
- uint64_t expect = EXPECT; \
- if (value == EXPECT) { \
- printf("ERROR: \"%s\" 0x%04llx == 0x%04llx at %s:%d\n", #N, value, \
- expect, __FILE__, __LINE__); \
- err++; \
- } \
- } while (0)
+#include "hex_test.h"
#define WRITE_REG_NOCLOBBER(output, reg_name, input) \
asm volatile(reg_name " = %1\n\t" \
@@ -85,35 +65,35 @@ static inline void write_control_registers(void)
uint32_t result = 0;
WRITE_REG_NOCLOBBER(result, "usr", 0xffffffff);
- check(result, 0x3ecfff3f);
+ check32(result, 0x3ecfff3f);
WRITE_REG_NOCLOBBER(result, "gp", 0xffffffff);
- check(result, 0xffffffc0);
+ check32(result, 0xffffffc0);
WRITE_REG_NOCLOBBER(result, "upcyclelo", 0xffffffff);
- check(result, 0x00000000);
+ check32(result, 0x00000000);
WRITE_REG_NOCLOBBER(result, "upcyclehi", 0xffffffff);
- check(result, 0x00000000);
+ check32(result, 0x00000000);
WRITE_REG_NOCLOBBER(result, "utimerlo", 0xffffffff);
- check(result, 0x00000000);
+ check32(result, 0x00000000);
WRITE_REG_NOCLOBBER(result, "utimerhi", 0xffffffff);
- check(result, 0x00000000);
+ check32(result, 0x00000000);
/*
* PC is special. Setting it to these values
* should cause a catastrophic failure.
*/
WRITE_REG_ENCODED(result, "pc", 0x00000000, PC_EQ_R0);
- check_ne(result, 0x00000000);
+ check32_ne(result, 0x00000000);
WRITE_REG_ENCODED(result, "pc", 0x00000001, PC_EQ_R0);
- check_ne(result, 0x00000001);
+ check32_ne(result, 0x00000001);
WRITE_REG_ENCODED(result, "pc", 0xffffffff, PC_EQ_R0);
- check_ne(result, 0xffffffff);
+ check32_ne(result, 0xffffffff);
}
static inline void write_control_register_pairs(void)
@@ -121,23 +101,23 @@ static inline void write_control_register_pairs(void)
uint64_t result = 0;
WRITE_REG_NOCLOBBER(result, "c11:10", 0xffffffffffffffff);
- check(result, 0xffffffc0ffffffff);
+ check64(result, 0xffffffc0ffffffff);
WRITE_REG_NOCLOBBER(result, "c15:14", 0xffffffffffffffff);
- check(result, 0x0000000000000000);
+ check64(result, 0x0000000000000000);
WRITE_REG_NOCLOBBER(result, "c31:30", 0xffffffffffffffff);
- check(result, 0x0000000000000000);
+ check64(result, 0x0000000000000000);
WRITE_REG_PAIR_ENCODED(result, "c9:8", (uint64_t) 0x0000000000000000,
C9_8_EQ_R1_0);
- check_ne(result, 0x000000000000000);
+ check64_ne(result, 0x000000000000000);
WRITE_REG_PAIR_ENCODED(result, "c9:8", 0x0000000100000000, C9_8_EQ_R1_0);
- check_ne(result, 0x0000000100000000);
+ check64_ne(result, 0x0000000100000000);
WRITE_REG_PAIR_ENCODED(result, "c9:8", 0xffffffffffffffff, C9_8_EQ_R1_0);
- check_ne(result, 0xffffffffffffffff);
+ check64_ne(result, 0xffffffffffffffff);
}
int main()
@@ -1,5 +1,5 @@
/*
- * Copyright(c) 2022 Qualcomm Innovation Center, Inc. All Rights Reserved.
+ * Copyright(c) 2022-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -24,35 +24,7 @@
int err;
-static void __check(int line, uint32_t val, uint32_t expect)
-{
- if (val != expect) {
- printf("ERROR at line %d: %d != %d\n", line, val, expect);
- err++;
- }
-}
-
-#define check(RES, EXP) __check(__LINE__, RES, EXP)
-
-static void __check32(int line, uint32_t val, uint32_t expect)
-{
- if (val != expect) {
- printf("ERROR at line %d: 0x%08x != 0x%08x\n", line, val, expect);
- err++;
- }
-}
-
-#define check32(RES, EXP) __check32(__LINE__, RES, EXP)
-
-static void __check64(int line, uint64_t val, uint64_t expect)
-{
- if (val != expect) {
- printf("ERROR at line %d: 0x%016llx != 0x%016llx\n", line, val, expect);
- err++;
- }
-}
-
-#define check64(RES, EXP) __check64(__LINE__, RES, EXP)
+#include "hex_test.h"
/*
* Some of the instructions tested are only available on certain versions
@@ -61,53 +33,6 @@ static void __check64(int line, uint64_t val, uint64_t expect)
#define CORE_HAS_AUDIO (__HEXAGON_ARCH__ >= 67 && defined(__HEXAGON_AUDIO__))
#define CORE_IS_V67 (__HEXAGON_ARCH__ >= 67)
-/* Define the bits in Hexagon USR register */
-#define USR_OVF_BIT 0 /* Sticky saturation overflow */
-#define USR_FPINVF_BIT 1 /* IEEE FP invalid sticky flag */
-#define USR_FPDBZF_BIT 2 /* IEEE FP divide-by-zero sticky flag */
-#define USR_FPOVFF_BIT 3 /* IEEE FP overflow sticky flag */
-#define USR_FPUNFF_BIT 4 /* IEEE FP underflow sticky flag */
-#define USR_FPINPF_BIT 5 /* IEEE FP inexact sticky flag */
-
-/* Corresponding values in USR */
-#define USR_CLEAR 0
-#define USR_OVF (1 << USR_OVF_BIT)
-#define USR_FPINVF (1 << USR_FPINVF_BIT)
-#define USR_FPDBZF (1 << USR_FPDBZF_BIT)
-#define USR_FPOVFF (1 << USR_FPOVFF_BIT)
-#define USR_FPUNFF (1 << USR_FPUNFF_BIT)
-#define USR_FPINPF (1 << USR_FPINPF_BIT)
-
-/* Some useful floating point values */
-const uint32_t SF_INF = 0x7f800000;
-const uint32_t SF_QNaN = 0x7fc00000;
-const uint32_t SF_SNaN = 0x7fb00000;
-const uint32_t SF_QNaN_neg = 0xffc00000;
-const uint32_t SF_SNaN_neg = 0xffb00000;
-const uint32_t SF_HEX_NaN = 0xffffffff;
-const uint32_t SF_zero = 0x00000000;
-const uint32_t SF_zero_neg = 0x80000000;
-const uint32_t SF_one = 0x3f800000;
-const uint32_t SF_one_recip = 0x3f7f0001; /* 0.9960... */
-const uint32_t SF_one_invsqrta = 0x3f7f0000; /* 0.99609375 */
-const uint32_t SF_two = 0x40000000;
-const uint32_t SF_four = 0x40800000;
-const uint32_t SF_small_neg = 0xab98fba8;
-const uint32_t SF_large_pos = 0x5afa572e;
-
-const uint64_t DF_QNaN = 0x7ff8000000000000ULL;
-const uint64_t DF_SNaN = 0x7ff7000000000000ULL;
-const uint64_t DF_QNaN_neg = 0xfff8000000000000ULL;
-const uint64_t DF_SNaN_neg = 0xfff7000000000000ULL;
-const uint64_t DF_HEX_NaN = 0xffffffffffffffffULL;
-const uint64_t DF_zero = 0x0000000000000000ULL;
-const uint64_t DF_zero_neg = 0x8000000000000000ULL;
-const uint64_t DF_any = 0x3f80000000000000ULL;
-const uint64_t DF_one = 0x3ff0000000000000ULL;
-const uint64_t DF_one_hh = 0x3ff001ff80000000ULL; /* 1.00048... */
-const uint64_t DF_small_neg = 0xbd731f7500000000ULL;
-const uint64_t DF_large_pos = 0x7f80000000000001ULL;
-
/*
* Templates for functions to execute an instruction
*
@@ -122,12 +47,6 @@ const uint64_t DF_large_pos = 0x7f80000000000001ULL;
* Xx read/write
*/
-/* Clear bits 0-5 in USR */
-#define CLEAR_USRBITS \
- "r2 = usr\n\t" \
- "r2 = and(r2, #0xffffffc0)\n\t" \
- "usr = r2\n\t"
-
/* Template for instructions with one register operand */
#define FUNC_x_OP_x(RESTYPE, SRCTYPE, NAME, INSN) \
static RESTYPE NAME(SRCTYPE src, uint32_t *usr_result) \
@@ -508,7 +427,7 @@ FUNC_Rp_OP_R(sfinvsqrta, "%0, p2 = sfinvsqrta(%3)")
uint32_t usr_result; \
result = FUNC(src, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_R_OP_R(FUNC, SRC, RES, USR_RES) \
@@ -532,8 +451,8 @@ TEST_x_OP_x(uint64_t, check64, uint32_t, FUNC, SRC, RES, USR_RES)
uint32_t usr_result; \
result = FUNC(src, &pred_result, &usr_result); \
CHECKFN(result, RES); \
- check(pred_result, PRED_RES); \
- check(usr_result, USR_RES); \
+ check32(pred_result, PRED_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_Rp_OP_R(FUNC, SRC, RES, PRED_RES, USR_RES) \
@@ -548,7 +467,7 @@ TEST_xp_OP_x(uint32_t, check32, uint32_t, FUNC, SRC, RES, PRED_RES, USR_RES)
uint32_t usr_result; \
result = FUNC(src1, src2, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_P_OP_PP(FUNC, SRC1, SRC2, RES, USR_RES) \
@@ -585,8 +504,8 @@ TEST_x_OP_xx(uint64_t, check64, uint64_t, uint32_t, \
uint32_t usr_result; \
result = FUNC(src1, src2, &pred_result, &usr_result); \
CHECKFN(result, RES); \
- check(pred_result, PRED_RES); \
- check(usr_result, USR_RES); \
+ check32(pred_result, PRED_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_Rp_OP_RR(FUNC, SRC1, SRC2, RES, PRED_RES, USR_RES) \
@@ -602,7 +521,7 @@ TEST_xp_OP_xx(uint32_t, check32, uint32_t, uint32_t, FUNC, SRC1, SRC2, \
uint32_t usr_result; \
result = FUNC(src1, src2, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_R_OP_RI(FUNC, SRC1, SRC2, RES, USR_RES) \
@@ -622,7 +541,7 @@ TEST_x_OP_xI(uint32_t, check64, uint64_t, \
uint32_t usr_result; \
result = FUNC(result, src1, src2, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_XR_OP_RR(FUNC, RESIN, SRC1, SRC2, RES, USR_RES) \
@@ -647,7 +566,7 @@ TEST_Xx_OP_xx(uint64_t, check64, uint32_t, uint32_t, \
uint32_t usr_result; \
result = FUNC(result, src1, src2, &pred_res, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_XPp_OP_PP(FUNC, RESIN, SRC1, SRC2, RES, PRED_RES, USR_RES) \
@@ -664,7 +583,7 @@ TEST_Xxp_OP_xx(uint64_t, check64, uint64_t, uint64_t, FUNC, RESIN, SRC1, SRC2, \
uint32_t usr_result; \
result = FUNC(result, src1, src2, pred, &usr_result); \
CHECKFN(result, RES); \
- check(usr_result, USR_RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_XR_OP_RRp(FUNC, RESIN, SRC1, SRC2, PRED, RES, USR_RES) \
@@ -679,8 +598,8 @@ TEST_Xx_OP_xxp(uint32_t, check32, uint32_t, uint32_t, \
SRC2TYPE src2 = SRC2; \
uint32_t usr_result; \
result = FUNC(src1, src2, &usr_result); \
- check(result, RES); \
- check(usr_result, USR_RES); \
+ check32(result, RES); \
+ check32(usr_result, USR_RES); \
} while (0)
#define TEST_CMP_RR(FUNC, SRC1, SRC2, RES, USR_RES) \
@@ -91,8 +91,25 @@ HEX_TESTS += v73_scalar
TESTS += $(HEX_TESTS)
+atomics: atomics.c hex_test.h
+brev: brev.c hex_test.h
+circ: circ.c hex_test.h
+dual_stores: dual_stores.c hex_test.h
+fpstuff: fpstuff.c hex_test.h
+hex_sigsegv: hex_sigsegv.c hex_test.h
+load_align: load_align.c hex_test.h
+load_unpack: load_unpack.c hex_test.h
+mem_noshuf_exception: mem_noshuf_exception.c hex_test.h
+mem_noshuf: mem_noshuf.c hex_test.h
+misc: misc.c hex_test.h
+multi_result: multi_result.c hex_test.h
+overflow: overflow.c hex_test.h
+preg_alias: preg_alias.c hex_test.h
+read_write_overlap: read_write_overlap.c hex_test.h
+reg_mut: reg_mut.c hex_test.h
+
# This test has to be compiled for the -mv67t target
-usr: usr.c
+usr: usr.c hex_test.h
$(CC) $(CFLAGS) -mv67t -O2 -Wno-inline-asm -Wno-expansion-to-defined $< -o $@ $(LDFLAGS)
# Build this test with -mv71 to exercise the CABAC instruction
Move test infra to header file check functions (always print line number on error) USR manipulation Useful floating point values Use stdint.h types Use stdbool.h bool where appropriate Use trip counts local to for loop Suggested-by: Anton Johansson <anjo@rev.ng> Signed-off-by: Taylor Simpson <tsimpson@quicinc.com> Reviewed-by: Anton Johansson <anjo@rev.ng> Tested-by: Anton Johansson <anjo@rev.ng> Message-Id: <20230522174341.1805460-1-tsimpson@quicinc.com> --- tests/tcg/hexagon/hex_test.h | 145 ++++++++++ tests/tcg/hexagon/atomics.c | 51 ++-- tests/tcg/hexagon/brev.c | 73 +++-- tests/tcg/hexagon/circ.c | 152 +++++----- tests/tcg/hexagon/dual_stores.c | 25 +- tests/tcg/hexagon/fpstuff.c | 341 ++++++++++------------- tests/tcg/hexagon/hex_sigsegv.c | 46 +-- tests/tcg/hexagon/load_align.c | 111 +++----- tests/tcg/hexagon/load_unpack.c | 159 +++++------ tests/tcg/hexagon/mem_noshuf.c | 163 +++++------ tests/tcg/hexagon/mem_noshuf_exception.c | 52 ++-- tests/tcg/hexagon/misc.c | 338 +++++++++++----------- tests/tcg/hexagon/multi_result.c | 171 +++++------- tests/tcg/hexagon/overflow.c | 61 ++-- tests/tcg/hexagon/preg_alias.c | 111 ++++---- tests/tcg/hexagon/read_write_overlap.c | 55 ++-- tests/tcg/hexagon/reg_mut.c | 54 ++-- tests/tcg/hexagon/usr.c | 109 +------- tests/tcg/hexagon/Makefile.target | 19 +- 19 files changed, 1030 insertions(+), 1206 deletions(-) create mode 100644 tests/tcg/hexagon/hex_test.h