xref: /openbmc/qemu/tests/tcg/hexagon/mem_noshuf.c (revision 0d57cd61d95fbbe86a1ce3b2ef2f8f1254b4116a)

/*
 *  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
 *  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/>.
 */

#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.
 *  This is important when the addresses overlap.
 *  The store instruction in slot 1 effectively executes first,
 *  followed by the load instruction in slot 0.
 */

#define MEM_NOSHUF32(NAME, ST_TYPE, LD_TYPE, ST_OP, LD_OP) \
static inline uint32_t NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
{ \
    uint32_t ret; \
    asm volatile("{\n\t" \
                 "    " #ST_OP "(%1) = %3\n\t" \
                 "    %0 = " #LD_OP "(%2)\n\t" \
                 "}:mem_noshuf\n" \
                 : "=r"(ret) \
                 : "r"(p), "r"(q), "r"(x) \
                 : "memory"); \
    return ret; \
}

#define MEM_NOSHUF64(NAME, ST_TYPE, LD_TYPE, ST_OP, LD_OP) \
static inline uint64_t NAME(ST_TYPE * p, LD_TYPE * q, ST_TYPE x) \
{ \
    uint64_t ret; \
    asm volatile("{\n\t" \
                 "    " #ST_OP "(%1) = %3\n\t" \
                 "    %0 = " #LD_OP "(%2)\n\t" \
                 "}:mem_noshuf\n" \
                 : "=r"(ret) \
                 : "r"(p), "r"(q), "r"(x) \
                 : "memory"); \
    return ret; \
}

/* Store byte combinations */
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,  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,  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,  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"
                 "%0 = %3\n\t"
                 "{\n\t"
                 "    memw(%1) = %4\n\t"
                 "    if (!p0) %0 = memw(%2)\n\t"
                 "}:mem_noshuf\n"
                 : "=&r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(y), "r"(pred)
                 : "p0", "memory");
    return ret;
}

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"
                 "%0 = %3\n\t"
                 "r7 = %2\n\t"
                 "{\n\t"
                 "    memw(%1) = %4\n\t"
                 "    if (!p0) %0 = memw(r7++#4)\n\t"
                 "}:mem_noshuf\n"
                 : "=&r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(y), "r"(pred)
                 : "r7", "p0", "memory");
    return ret;
}

static inline int64_t pred_ld_sd(bool pred, int64_t *p, int64_t *q,
                                 int64_t x, int64_t y)
{
    int64_t ret;
    asm volatile("p0 = cmp.eq(%5, #0)\n\t"
                 "%0 = %3\n\t"
                 "{\n\t"
                 "    memd(%1) = %4\n\t"
                 "    if (!p0) %0 = memd(%2)\n\t"
                 "}:mem_noshuf\n"
                 : "=&r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(y), "r"(pred)
                 : "p0", "memory");
    return ret;
}

static inline int64_t pred_ld_sd_pi(bool pred, int64_t *p, int64_t *q,
                                    int64_t x, int64_t y)
{
    int64_t ret;
    asm volatile("p0 = cmp.eq(%5, #0)\n\t"
                 "%0 = %3\n\t"
                 "r7 = %2\n\t"
                 "{\n\t"
                 "    memd(%1) = %4\n\t"
                 "    if (!p0) %0 = memd(r7++#8)\n\t"
                 "}:mem_noshuf\n"
                 : "=&r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(y), "r"(pred)
                 : "r7", "p0", "memory");
    return ret;
}

static inline int32_t cancel_sw_lb(bool pred, int32_t *p, int8_t *q, int32_t x)
{
    int32_t ret;
    asm volatile("p0 = cmp.eq(%4, #0)\n\t"
                 "{\n\t"
                 "    if (!p0) memw(%1) = %3\n\t"
                 "    %0 = memb(%2)\n\t"
                 "}:mem_noshuf\n"
                 : "=r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(pred)
                 : "p0", "memory");
    return ret;
}

static inline int64_t cancel_sw_ld(bool pred, int32_t *p, int64_t *q, int32_t x)
{
    int64_t ret;
    asm volatile("p0 = cmp.eq(%4, #0)\n\t"
                 "{\n\t"
                 "    if (!p0) memw(%1) = %3\n\t"
                 "    %0 = memd(%2)\n\t"
                 "}:mem_noshuf\n"
                 : "=r"(ret)
                 : "r"(p), "r"(q), "r"(x), "r"(pred)
                 : "p0", "memory");
    return ret;
}

typedef union {
    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 main()
{
    Memory n;
    uint32_t res32;
    uint64_t res64;

    /*
     * Store byte combinations
     */
    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lb(&n.b[0], &n.b[0], 0x87);
    check32(res32, 0xffffff87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lub(&n.b[0], &n.ub[0], 0x87);
    check32(res32, 0x00000087);

    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lh(&n.b[0], &n.h[0], 0x87);
    check32(res32, 0xffffff87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sb_luh(&n.b[0], &n.uh[0], 0x87);
    check32(res32, 0x0000ff87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lw(&n.b[0], &n.w[0], 0x87);
    check32(res32, 0xffffff87);

    n.d[0] = ~0LL;
    res64 = mem_noshuf_sb_ld(&n.b[0], &n.d[0], 0x87);
    check64(res64, 0xffffffffffffff87LL);

    /*
     * Store half combinations
     */
    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lb(&n.h[0], &n.b[0], 0x8787);
    check32(res32, 0xffffff87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lub(&n.h[0], &n.ub[1], 0x8f87);
    check32(res32, 0x0000008f);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lh(&n.h[0], &n.h[0], 0x8a87);
    check32(res32, 0xffff8a87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_luh(&n.h[0], &n.uh[0], 0x8a87);
    check32(res32, 0x8a87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lw(&n.h[1], &n.w[0], 0x8a87);
    check32(res32, 0x8a87ffff);

    n.w[0] = ~0;
    res64 = mem_noshuf_sh_ld(&n.h[1], &n.d[0], 0x8a87);
    check64(res64, 0xffffffff8a87ffffLL);

    /*
     * Store word combinations
     */
    n.w[0] = ~0;
    res32 = mem_noshuf_sw_lb(&n.w[0], &n.b[0], 0x12345687);
    check32(res32, 0xffffff87);

    n.w[0] = ~0;
    res32 = mem_noshuf_sw_lub(&n.w[0], &n.ub[0], 0x12345687);
    check32(res32, 0x00000087);

    n.w[0] = ~0;
    res32 = mem_noshuf_sw_lh(&n.w[0], &n.h[0], 0x1234f678);
    check32(res32, 0xfffff678);

    n.w[0] = ~0;
    res32 = mem_noshuf_sw_luh(&n.w[0], &n.uh[0], 0x12345678);
    check32(res32, 0x00005678);

    n.w[0] = ~0;
    res32 = mem_noshuf_sw_lw(&n.w[0], &n.w[0], 0x12345678);
    check32(res32, 0x12345678);

    n.d[0] = ~0LL;
    res64 = mem_noshuf_sw_ld(&n.w[0], &n.d[0], 0x12345678);
    check64(res64, 0xffffffff12345678LL);

    /*
     * Store double combinations
     */
    n.d[0] = ~0LL;
    res32 = mem_noshuf_sd_lb(&n.d[0], &n.b[1], 0x123456789abcdef0);
    check32(res32, 0xffffffde);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sd_lub(&n.d[0], &n.ub[1], 0x123456789abcdef0);
    check32(res32, 0x000000de);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sd_lh(&n.d[0], &n.h[1], 0x123456789abcdef0);
    check32(res32, 0xffff9abc);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sd_luh(&n.d[0], &n.uh[1], 0x123456789abcdef0);
    check32(res32, 0x00009abc);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sd_lw(&n.d[0], &n.w[1], 0x123456789abcdef0);
    check32(res32, 0x12345678);

    n.d[0] = ~0LL;
    res64 = mem_noshuf_sd_ld(&n.d[0], &n.d[0], 0x123456789abcdef0);
    check64(res64, 0x123456789abcdef0LL);

    /*
     * Predicated word stores
     */
    n.w[0] = ~0;
    res32 = cancel_sw_lb(false, &n.w[0], &n.b[0], 0x12345678);
    check32(res32, 0xffffffff);

    n.w[0] = ~0;
    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(false, &n.w[0], &n.d[0], 0x12345678);
    check64(res64, 0xffffffffffffffffLL);

    n.d[0] = ~0LL;
    res64 = cancel_sw_ld(true, &n.w[0], &n.d[0], 0x12345678);
    check64(res64, 0xffffffff12345678LL);

    n.d[0] = ~0LL;
    res64 = cancel_sw_ld(false, &n.w[1], &n.d[0], 0x12345678);
    check64(res64, 0xffffffffffffffffLL);

    n.d[0] = ~0LL;
    res64 = cancel_sw_ld(true, &n.w[1], &n.d[0], 0x12345678);
    check64(res64, 0x12345678ffffffffLL);

    /*
     * No overlap tests
     */
    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lb(&n.b[1], &n.b[0], 0x87);
    check32(res32, 0xffffffff);

    n.w[0] = ~0;
    res32 = mem_noshuf_sb_lb(&n.b[0], &n.b[1], 0x87);
    check32(res32, 0xffffffff);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lh(&n.h[1], &n.h[0], 0x8787);
    check32(res32, 0xffffffff);

    n.w[0] = ~0;
    res32 = mem_noshuf_sh_lh(&n.h[0], &n.h[1], 0x8787);
    check32(res32, 0xffffffff);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sw_lw(&n.w[0], &n.w[1], 0x12345678);
    check32(res32, 0xffffffff);

    n.d[0] = ~0LL;
    res32 = mem_noshuf_sw_lw(&n.w[1], &n.w[0], 0x12345678);
    check32(res32, 0xffffffff);

    n.d[0] = ~0LL;
    n.d[1] = ~0LL;
    res64 = mem_noshuf_sd_ld(&n.d[1], &n.d[0], 0x123456789abcdef0LL);
    check64(res64, 0xffffffffffffffffLL);

    n.d[0] = ~0LL;
    n.d[1] = ~0LL;
    res64 = mem_noshuf_sd_ld(&n.d[0], &n.d[1], 0x123456789abcdef0LL);
    check64(res64, 0xffffffffffffffffLL);

    n.w[0] = ~0;
    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(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(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(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(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(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(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(true, &n.d[0], &n.d[0],
                          0x1234567812345678LL, 0xc0ffeedac0ffeedaLL);
    check64(res64, 0xc0ffeedac0ffeedaLL);
    check64(n.d[0], 0xc0ffeedac0ffeedaLL);

    puts(err ? "FAIL" : "PASS");
    return err;
}