 @@ -1,14 +1,14 @@
-/* $NetBSD: trap.c,v 1.135 2019/11/21 19:23:58 ad Exp $ */
+/* $NetBSD: trap.c,v 1.136 2021/07/19 22:21:36 thorpej Exp $ */
 /*-
  * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, and by Ross Harvey.
+ *
  * 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
 @@ -77,33 +77,35 @@
  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
  * Carnegie Mellon requests users of this software to return to
+ *
  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #define	__UFETCHSTORE_PRIVATE	/* see handle_opdec() */
 #include "opt_fix_unaligned_vax_fp.h"
 #include "opt_ddb.h"
 #include "opt_multiprocessor.h"
 #include <sys/cdefs.h>			/* RCS ID & Copyright macro defns */
-__KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.135 2019/11/21 19:23:58 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.136 2021/07/19 22:21:36 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/syscall.h>
 #include <sys/buf.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/cpu.h>
 #include <sys/atomic.h>
 #include <uvm/uvm_extern.h>
 @@ -865,109 +867,131 @@ unaligned_fixup(u_long va, u_long opcode
+	 *
 	 * We never allow bad data to be unknowingly used by the user process.
 	 * That is, if we can't access the address needed to fix up the trap,
 	 * we cause a SIGSEGV rather than letting the user process go on
 	 * without warning.
+	 *
 	 * If we're trying to do a fixup, we assume that things
 	 * will be botched.  If everything works out OK,
 	 * unaligned_{load,store}_* clears the signal flag.
 	 */
 	signo = SIGSEGV;
 	if (dofix && selected_tab->fixable) {
 		switch (opcode) {
-		case 0x0c:			/* ldwu */
+		case op_ldwu:
 			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
 			unaligned_load_integer(worddata);
 			break;
-		case 0x0d:			/* stw */
+		case op_stw:
 			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
 			unaligned_store_integer(worddata);
 			break;
 #ifdef FIX_UNALIGNED_VAX_FP
-		case 0x20:			/* ldf */
+		case op_ldf:
 			unaligned_load_floating(intdata, Ffloat_to_reg);
 			break;
-		case 0x21:			/* ldg */
+		case op_ldg:
 			unaligned_load_floating(longdata, Gfloat_reg_cvt);
 			break;
 #endif
-		case 0x22:			/* lds */
+		case op_lds:
 			unaligned_load_floating(intdata, Sfloat_to_reg);
 			break;
-		case 0x23:			/* ldt */
+		case op_ldt:
 			unaligned_load_floating(longdata, Tfloat_reg_cvt);
 			break;
 #ifdef FIX_UNALIGNED_VAX_FP
-		case 0x24:			/* stf */
+		case op_stf:
 			unaligned_store_floating(intdata, reg_to_Ffloat);
 			break;
-		case 0x25:			/* stg */
+		case op_stg:
 			unaligned_store_floating(longdata, Gfloat_reg_cvt);
 			break;
 #endif
-		case 0x26:			/* sts */
+		case op_sts:
 			unaligned_store_floating(intdata, reg_to_Sfloat);
 			break;
-		case 0x27:			/* stt */
+		case op_stt:
 			unaligned_store_floating(longdata, Tfloat_reg_cvt);
 			break;
-		case 0x28:			/* ldl */
+		case op_ldl:
 			unaligned_load_integer(intdata);
 			break;
-		case 0x29:			/* ldq */
+		case op_ldq:
 			unaligned_load_integer(longdata);
 			break;
-		case 0x2c:			/* stl */
+		case op_stl:
 			unaligned_store_integer(intdata);
 			break;
-		case 0x2d:			/* stq */
+		case op_stq:
 			unaligned_store_integer(longdata);
 			break;
 #ifdef DIAGNOSTIC
 		default:
 			panic("unaligned_fixup: can't get here");
 #endif
+		}
+	}
 	/*
 	 * Force SIGBUS if requested.
 	 */
 	if (dosigbus)
 		signo = SIGBUS;
 	/*
 	 * Write back USP.
 	 */
 	alpha_pal_wrusp(l->l_md.md_tf->tf_regs[FRAME_SP]);
 	return (signo);
+}
 static struct evcnt emul_bwx_ldbu =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "ldbu");
 static struct evcnt emul_bwx_ldwu =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "ldwu");
 static struct evcnt emul_bwx_stb =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "stb");
 static struct evcnt emul_bwx_stw =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "stw");
 static struct evcnt emul_bwx_sextb =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "sextb");
 static struct evcnt emul_bwx_sextw =
     EVCNT_INITIALIZER(EVCNT_TYPE_TRAP, NULL, "emul bwx", "sextw");
 EVCNT_ATTACH_STATIC(emul_bwx_ldbu);
 EVCNT_ATTACH_STATIC(emul_bwx_ldwu);
 EVCNT_ATTACH_STATIC(emul_bwx_stb);
 EVCNT_ATTACH_STATIC(emul_bwx_stw);
 EVCNT_ATTACH_STATIC(emul_bwx_sextb);
 EVCNT_ATTACH_STATIC(emul_bwx_sextw);
 #define	EMUL_COUNT(ev)	atomic_inc_64(&(ev).ev_count)
 /*
  * Reserved/unimplemented instruction (opDec fault) handler
+ *
  * Argument is the process that caused it.  No useful information
  * is passed to the trap handler other than the fault type.  The
  * address of the instruction that caused the fault is 4 less than
  * the PC stored in the trap frame.
+ *
  * If the instruction is emulated successfully, this function returns 0.
  * Otherwise, this function returns the signal to deliver to the process,
  * and fills in *ucodep with the code to be delivered.
  */
 int
 @@ -976,117 +1000,131 @@ handle_opdec(struct lwp *l, u_long *ucod
 	alpha_instruction inst;
 	register_t *regptr, memaddr;
 	uint64_t inst_pc;
 	int sig;
 	/*
 	 * Read USP into frame in case it's going to be used or modified.
 	 * This keeps us from having to check for it in lots of places
 	 * later.
 	 */
 	l->l_md.md_tf->tf_regs[FRAME_SP] = alpha_pal_rdusp();
 	inst_pc = memaddr = l->l_md.md_tf->tf_regs[FRAME_PC] - 4;
-	if (copyin((void *)inst_pc, &inst, sizeof (inst)) != 0) {
+	if (ufetch_int((void *)inst_pc, &inst.bits) != 0) {
 		/*
 		 * really, this should never happen, but in case it
 		 * does we handle it.
 		 */
 		printf("WARNING: handle_opdec() couldn't fetch instruction\n");
 		goto sigsegv;
+	}
 	switch (inst.generic_format.opcode) {
 	case op_ldbu:
 	case op_ldwu:
 	case op_stw:
 	case op_stb:
 		regptr = irp(l, inst.mem_format.rb);
 		if (regptr != NULL)
 			memaddr = *regptr;
 		else
 			memaddr = 0;
 		memaddr += inst.mem_format.displacement;
 		regptr = irp(l, inst.mem_format.ra);
 		if (inst.mem_format.opcode == op_ldwu ||
 		    inst.mem_format.opcode == op_stw) {
 			if (memaddr & 0x01) {
 				if (inst.mem_format.opcode == op_ldwu) {
 					EMUL_COUNT(emul_bwx_ldwu);
 				} else {
 					EMUL_COUNT(emul_bwx_stw);
+				}
 				sig = unaligned_fixup(memaddr,
 				    inst.mem_format.opcode,
 				    inst.mem_format.ra, l);
 				if (sig)
 					goto unaligned_fixup_sig;
 				break;
+			}
+		}
 		/*
 		 * We know the addresses are aligned, so it's safe to
 		 * use _u{fetch,store}_{8,16}().  Note, these are
 		 * __UFETCHSTORE_PRIVATE, but this is MD code, and
 		 * we know the details of the alpha implementation.
 		 */
 		if (inst.mem_format.opcode == op_ldbu) {
 			uint8_t b;
-			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
+			EMUL_COUNT(emul_bwx_ldbu);
-			if (copyin((void *)memaddr, &b, sizeof (b)) != 0)
+			if (_ufetch_8((void *)memaddr, &b) != 0)
 				goto sigsegv;
 			if (regptr != NULL)
 				*regptr = b;
 		} else if (inst.mem_format.opcode == op_ldwu) {
 			uint16_t w;
-			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
+			EMUL_COUNT(emul_bwx_ldwu);
-			if (copyin((void *)memaddr, &w, sizeof (w)) != 0)
+			if (_ufetch_16((void *)memaddr, &w) != 0)
 				goto sigsegv;
 			if (regptr != NULL)
 				*regptr = w;
 		} else if (inst.mem_format.opcode == op_stw) {
 			uint16_t w;
-			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
+			EMUL_COUNT(emul_bwx_stw);
 			w = (regptr != NULL) ? *regptr : 0;
-			if (copyout(&w, (void *)memaddr, sizeof (w)) != 0)
+			if (_ustore_16((void *)memaddr, w) != 0)
 				goto sigsegv;
 		} else if (inst.mem_format.opcode == op_stb) {
 			uint8_t b;
-			/* XXX ONLY WORKS ON LITTLE-ENDIAN ALPHA */
+			EMUL_COUNT(emul_bwx_stb);
 			b = (regptr != NULL) ? *regptr : 0;
-			if (copyout(&b, (void *)memaddr, sizeof (b)) != 0)
+			if (_ustore_8((void *)memaddr, b) != 0)
 				goto sigsegv;
+		}
 		break;
 	case op_intmisc:
 		if (inst.operate_generic_format.function == op_sextb &&
 		    inst.operate_generic_format.ra == 31) {
 			int8_t b;
 			EMUL_COUNT(emul_bwx_sextb);
 			if (inst.operate_generic_format.is_lit) {
 				b = inst.operate_lit_format.literal;
 			} else {
 				if (inst.operate_reg_format.sbz != 0)
 					goto sigill;
 				regptr = irp(l, inst.operate_reg_format.rb);
 				b = (regptr != NULL) ? *regptr : 0;
+			}
 			regptr = irp(l, inst.operate_generic_format.rc);
 			if (regptr != NULL)
 				*regptr = b;
 			break;
+		}
 		if (inst.operate_generic_format.function == op_sextw &&
 		    inst.operate_generic_format.ra == 31) {
 			int16_t w;
 			EMUL_COUNT(emul_bwx_sextw);
 			if (inst.operate_generic_format.is_lit) {
 				w = inst.operate_lit_format.literal;
 			} else {
 				if (inst.operate_reg_format.sbz != 0)
 					goto sigill;
 				regptr = irp(l, inst.operate_reg_format.rb);
 				w = (regptr != NULL) ? *regptr : 0;
+			}
 			regptr = irp(l, inst.operate_generic_format.rc);
 			if (regptr != NULL)
 				*regptr = w;
 			break;