Hexagon (target/hexagon) probe the stores in a packet at start of commit

When a packet has 2 stores, either both commit or neither commit.
At the beginning of gen_commit_packet, we check for multiple stores.
If there are multiple stores, call a helper that will probe each of
them before proceeding with the commit.

Note that we don't call the probe helper for packets with only one
store.  Therefore, we call process_store_log before anything else
involved in committing the packet.

We also fix a typo in the comment in process_store_log.

Test case added in tests/tcg/hexagon/hex_sigsegv.c

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Taylor Simpson <tsimpson@quicinc.com>
Message-Id: <1633036599-7637-1-git-send-email-tsimpson@quicinc.com>
This commit is contained in:
Taylor Simpson 2021-09-22 10:30:46 -05:00
parent e3acc2c196
commit c23b5764e7
5 changed files with 160 additions and 3 deletions

View File

@ -89,3 +89,5 @@ DEF_HELPER_4(sffms_lib, f32, env, f32, f32, f32)
DEF_HELPER_3(dfmpyfix, f64, env, f64, f64) DEF_HELPER_3(dfmpyfix, f64, env, f64, f64)
DEF_HELPER_4(dfmpyhh, f64, env, f64, f64, f64) DEF_HELPER_4(dfmpyhh, f64, env, f64, f64, f64)
DEF_HELPER_2(probe_pkt_scalar_store_s0, void, env, int)

View File

@ -377,6 +377,22 @@ int32_t HELPER(vacsh_pred)(CPUHexagonState *env,
return PeV; return PeV;
} }
static void probe_store(CPUHexagonState *env, int slot, int mmu_idx)
{
if (!(env->slot_cancelled & (1 << slot))) {
size1u_t width = env->mem_log_stores[slot].width;
target_ulong va = env->mem_log_stores[slot].va;
uintptr_t ra = GETPC();
probe_write(env, va, width, mmu_idx, ra);
}
}
/* Called during packet commit when there are two scalar stores */
void HELPER(probe_pkt_scalar_store_s0)(CPUHexagonState *env, int mmu_idx)
{
probe_store(env, 0, mmu_idx);
}
/* /*
* mem_noshuf * mem_noshuf
* Section 5.5 of the Hexagon V67 Programmer's Reference Manual * Section 5.5 of the Hexagon V67 Programmer's Reference Manual

View File

@ -419,7 +419,7 @@ static void process_store_log(DisasContext *ctx, Packet *pkt)
{ {
/* /*
* When a packet has two stores, the hardware processes * When a packet has two stores, the hardware processes
* slot 1 and then slot 2. This will be important when * slot 1 and then slot 0. This will be important when
* the memory accesses overlap. * the memory accesses overlap.
*/ */
if (pkt->pkt_has_store_s1 && !pkt->pkt_has_dczeroa) { if (pkt->pkt_has_store_s1 && !pkt->pkt_has_dczeroa) {
@ -471,10 +471,42 @@ static void update_exec_counters(DisasContext *ctx, Packet *pkt)
static void gen_commit_packet(DisasContext *ctx, Packet *pkt) static void gen_commit_packet(DisasContext *ctx, Packet *pkt)
{ {
/*
* If there is more than one store in a packet, make sure they are all OK
* before proceeding with the rest of the packet commit.
*
* dczeroa has to be the only store operation in the packet, so we go
* ahead and process that first.
*
* When there are two scalar stores, we probe the one in slot 0.
*
* Note that we don't call the probe helper for packets with only one
* store. Therefore, we call process_store_log before anything else
* involved in committing the packet.
*/
bool has_store_s0 = pkt->pkt_has_store_s0;
bool has_store_s1 = (pkt->pkt_has_store_s1 && !ctx->s1_store_processed);
if (pkt->pkt_has_dczeroa) {
/*
* The dczeroa will be the store in slot 0, check that we don't have
* a store in slot 1.
*/
g_assert(has_store_s0 && !has_store_s1);
process_dczeroa(ctx, pkt);
} else if (has_store_s0 && has_store_s1) {
/*
* process_store_log will execute the slot 1 store first,
* so we only have to probe the store in slot 0
*/
TCGv mem_idx = tcg_const_tl(ctx->mem_idx);
gen_helper_probe_pkt_scalar_store_s0(cpu_env, mem_idx);
tcg_temp_free(mem_idx);
}
process_store_log(ctx, pkt);
gen_reg_writes(ctx); gen_reg_writes(ctx);
gen_pred_writes(ctx, pkt); gen_pred_writes(ctx, pkt);
process_store_log(ctx, pkt);
process_dczeroa(ctx, pkt);
update_exec_counters(ctx, pkt); update_exec_counters(ctx, pkt);
if (HEX_DEBUG) { if (HEX_DEBUG) {
TCGv has_st0 = TCGv has_st0 =

View File

@ -28,6 +28,7 @@ first: $(HEX_SRC)/first.S
$(CC) -static -mv67 -nostdlib $^ -o $@ $(CC) -static -mv67 -nostdlib $^ -o $@
HEX_TESTS = first HEX_TESTS = first
HEX_TESTS += hex_sigsegv
HEX_TESTS += misc HEX_TESTS += misc
HEX_TESTS += preg_alias HEX_TESTS += preg_alias
HEX_TESTS += dual_stores HEX_TESTS += dual_stores

View File

@ -0,0 +1,106 @@
/*
* Copyright(c) 2021 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/>.
*/
/*
* Test the VLIW semantics of two stores in a packet
*
* When a packet has 2 stores, either both commit or neither commit.
* We test this with a packet that does stores to both NULL and a global
* variable, "should_not_change". After the SIGSEGV is caught, we check
* that the "should_not_change" value is the same.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#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];
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))
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))
jmp_buf jmp_env;
static void sig_segv(int sig, siginfo_t *info, void *puc)
{
check(sig, SIGSEGV);
segv_caught = 1;
longjmp(jmp_env, 1);
}
int main()
{
struct sigaction act;
/* SIGSEGV test */
act.sa_sigaction = sig_segv;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
chk_error(sigaction(SIGSEGV, &act, NULL));
if (setjmp(jmp_env) == 0) {
asm volatile("r18 = ##should_not_change\n\t"
"r19 = #0\n\t"
"{\n\t"
" memw(r18) = #7\n\t"
" memw(r19) = #0\n\t"
"}\n\t"
: : : "r18", "r19", "memory");
}
act.sa_handler = SIG_DFL;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
chk_error(sigaction(SIGSEGV, &act, NULL));
check(segv_caught, 1);
check(should_not_change, SHOULD_NOT_CHANGE_VAL);
puts(err ? "FAIL" : "PASS");
return err ? EXIT_FAILURE : EXIT_SUCCESS;
}