xref: /openbsd/regress/sys/arch/sparc64/emul-ldqstq/badfreg/main.c (revision a19f903f)

/*	$OpenBSD: main.c,v 1.1 2003/07/12 04:08:33 jason Exp $	*/

/*
 * Copyright (c) 2003 Jason L. Wright (jason@thought.net)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <err.h>
#include <string.h>
#include <unistd.h>

struct fpquad {
	u_int64_t x1;
	u_int64_t x2;
	u_int64_t x3;
	u_int64_t x4;
};

void test_ldq_f2_g0(struct fpquad *);
void test_ldq_f2_simm13(struct fpquad *);
void test_stq_f2_g0(struct fpquad *);
void test_stq_f2_simm13(struct fpquad *);
void test_ldq_f6_g0(struct fpquad *);
void test_ldq_f6_simm13(struct fpquad *);
void test_stq_f6_g0(struct fpquad *);
void test_stq_f6_simm13(struct fpquad *);
void test_ldq_f10_g0(struct fpquad *);
void test_ldq_f10_simm13(struct fpquad *);
void test_stq_f10_g0(struct fpquad *);
void test_stq_f10_simm13(struct fpquad *);
void test_ldq_f14_g0(struct fpquad *);
void test_ldq_f14_simm13(struct fpquad *);
void test_stq_f14_g0(struct fpquad *);
void test_stq_f14_simm13(struct fpquad *);
void test_ldq_f18_g0(struct fpquad *);
void test_ldq_f18_simm13(struct fpquad *);
void test_stq_f18_g0(struct fpquad *);
void test_stq_f18_simm13(struct fpquad *);
void test_ldq_f22_g0(struct fpquad *);
void test_ldq_f22_simm13(struct fpquad *);
void test_stq_f22_g0(struct fpquad *);
void test_stq_f22_simm13(struct fpquad *);
void test_ldq_f26_g0(struct fpquad *);
void test_ldq_f26_simm13(struct fpquad *);
void test_stq_f26_g0(struct fpquad *);
void test_stq_f26_simm13(struct fpquad *);
void test_ldq_f30_g0(struct fpquad *);
void test_ldq_f30_simm13(struct fpquad *);
void test_stq_f30_g0(struct fpquad *);
void test_stq_f30_simm13(struct fpquad *);
void test_ldq_f34_g0(struct fpquad *);
void test_ldq_f34_simm13(struct fpquad *);
void test_stq_f34_g0(struct fpquad *);
void test_stq_f34_simm13(struct fpquad *);
void test_ldq_f38_g0(struct fpquad *);
void test_ldq_f38_simm13(struct fpquad *);
void test_stq_f38_g0(struct fpquad *);
void test_stq_f38_simm13(struct fpquad *);
void test_ldq_f42_g0(struct fpquad *);
void test_ldq_f42_simm13(struct fpquad *);
void test_stq_f42_g0(struct fpquad *);
void test_stq_f42_simm13(struct fpquad *);
void test_ldq_f46_g0(struct fpquad *);
void test_ldq_f46_simm13(struct fpquad *);
void test_stq_f46_g0(struct fpquad *);
void test_stq_f46_simm13(struct fpquad *);
void test_ldq_f50_g0(struct fpquad *);
void test_ldq_f50_simm13(struct fpquad *);
void test_stq_f50_g0(struct fpquad *);
void test_stq_f50_simm13(struct fpquad *);
void test_ldq_f54_g0(struct fpquad *);
void test_ldq_f54_simm13(struct fpquad *);
void test_stq_f54_g0(struct fpquad *);
void test_stq_f54_simm13(struct fpquad *);
void test_ldq_f58_g0(struct fpquad *);
void test_ldq_f58_simm13(struct fpquad *);
void test_stq_f58_g0(struct fpquad *);
void test_stq_f58_simm13(struct fpquad *);
void test_ldq_f62_g0(struct fpquad *);
void test_ldq_f62_simm13(struct fpquad *);
void test_stq_f62_g0(struct fpquad *);
void test_stq_f62_simm13(struct fpquad *);

struct fptest {
	char *reg;
	char *ldst;
	char *dir;
	void (*func)(struct fpquad *);
} thetests[] = {
	{"2", "st", "reg", test_stq_f2_g0},
	{"2", "ld", "reg", test_ldq_f2_g0},
	{"2", "st", "imm", test_stq_f2_simm13},
	{"2", "ld", "imm", test_ldq_f2_simm13},
	{"6", "st", "reg", test_stq_f6_g0},
	{"6", "ld", "reg", test_ldq_f6_g0},
	{"6", "st", "imm", test_stq_f6_simm13},
	{"6", "ld", "imm", test_ldq_f6_simm13},
	{"10", "st", "reg", test_stq_f10_g0},
	{"10", "ld", "reg", test_ldq_f10_g0},
	{"10", "st", "imm", test_stq_f10_simm13},
	{"10", "ld", "imm", test_ldq_f10_simm13},
	{"14", "st", "reg", test_stq_f14_g0},
	{"14", "ld", "reg", test_ldq_f14_g0},
	{"14", "st", "imm", test_stq_f14_simm13},
	{"14", "ld", "imm", test_ldq_f14_simm13},
	{"18", "st", "reg", test_stq_f18_g0},
	{"18", "ld", "reg", test_ldq_f18_g0},
	{"18", "st", "imm", test_stq_f18_simm13},
	{"18", "ld", "imm", test_ldq_f18_simm13},
	{"22", "st", "reg", test_stq_f22_g0},
	{"22", "ld", "reg", test_ldq_f22_g0},
	{"22", "st", "imm", test_stq_f22_simm13},
	{"22", "ld", "imm", test_ldq_f22_simm13},
	{"26", "st", "reg", test_stq_f26_g0},
	{"26", "ld", "reg", test_ldq_f26_g0},
	{"26", "st", "imm", test_stq_f26_simm13},
	{"26", "ld", "imm", test_ldq_f26_simm13},
	{"30", "st", "reg", test_stq_f30_g0},
	{"30", "ld", "reg", test_ldq_f30_g0},
	{"30", "st", "imm", test_stq_f30_simm13},
	{"30", "ld", "imm", test_ldq_f30_simm13},
	{"34", "st", "reg", test_stq_f34_g0},
	{"34", "ld", "reg", test_ldq_f34_g0},
	{"34", "st", "imm", test_stq_f34_simm13},
	{"34", "ld", "imm", test_ldq_f34_simm13},
	{"38", "st", "reg", test_stq_f38_g0},
	{"38", "ld", "reg", test_ldq_f38_g0},
	{"38", "st", "imm", test_stq_f38_simm13},
	{"38", "ld", "imm", test_ldq_f38_simm13},
	{"42", "st", "reg", test_stq_f42_g0},
	{"42", "ld", "reg", test_ldq_f42_g0},
	{"42", "st", "imm", test_stq_f42_simm13},
	{"42", "ld", "imm", test_ldq_f42_simm13},
	{"46", "st", "reg", test_stq_f46_g0},
	{"46", "ld", "reg", test_ldq_f46_g0},
	{"46", "st", "imm", test_stq_f46_simm13},
	{"46", "ld", "imm", test_ldq_f46_simm13},
	{"50", "st", "reg", test_stq_f50_g0},
	{"50", "ld", "reg", test_ldq_f50_g0},
	{"50", "st", "imm", test_stq_f50_simm13},
	{"50", "ld", "imm", test_ldq_f50_simm13},
	{"54", "st", "reg", test_stq_f54_g0},
	{"54", "ld", "reg", test_ldq_f54_g0},
	{"54", "st", "imm", test_stq_f54_simm13},
	{"54", "ld", "imm", test_ldq_f54_simm13},
	{"58", "st", "reg", test_stq_f58_g0},
	{"58", "ld", "reg", test_ldq_f58_g0},
	{"58", "st", "imm", test_stq_f58_simm13},
	{"58", "ld", "imm", test_ldq_f58_simm13},
	{"62", "st", "reg", test_stq_f62_g0},
	{"62", "ld", "reg", test_ldq_f62_g0},
	{"62", "st", "imm", test_stq_f62_simm13},
	{"62", "ld", "imm", test_ldq_f62_simm13},
};
#define	NTESTS	(sizeof(thetests)/sizeof(thetests[0]))

void ill_catcher(int, siginfo_t *, void *);

int
main(int argc, char *argv[])
{
	struct fptest *fpt;
	struct fpquad fpq;
	struct sigaction sa;
	int i;

	if (argc != 4) {
		fprintf(stderr, "badreg regnum [ld|st] [reg|imm]\n");
		return (1);
	}

	for (i = 0; i < NTESTS; i++) {
		fpt = thetests + i;
		if (strcmp(fpt->reg, argv[1]) == 0 &&
		    strcmp(fpt->ldst, argv[2]) == 0 &&
		    strcmp(fpt->dir, argv[3]) == 0)
			break;
	}
	if (i == NTESTS)
		errx(1, "unknown test: %s %s %s", argv[1], argv[2], argv[3]);

	sa.sa_sigaction = ill_catcher;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_SIGINFO;

	if (sigaction(SIGILL, &sa, NULL) == -1)
		err(1, "sigaction");

	(*fpt->func)(&fpq);
	err(1, "%s %s %s did not generate sigill", argv[1], argv[2], argv[3]);
	return (0);
}

void
ill_catcher(int sig, siginfo_t *si, void *v)
{
	_exit(0);
}