--- np2/i386c/ia32/exception.c	2004/01/27 15:56:57	1.6
+++ np2/i386c/ia32/exception.c	2011/12/17 02:39:06	1.25
@@ -1,5 +1,3 @@
-/*	$Id: exception.c,v 1.6 2004/01/27 15:56:57 monaka Exp $	*/
-
 /*
  * Copyright (c) 2003 NONAKA Kimihiro
  * All rights reserved.
@@ -12,8 +10,6 @@
  * 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.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@@ -72,26 +68,31 @@ exception(int num, int error_code)
 
 	__ASSERT((unsigned int)num < EXCEPTION_NUM);
 
+#if 0
+	iptrace_out();
+	debugwriteseg("execption.bin", &CPU_CS_DESC, CPU_PREV_EIP & 0xffff0000, 0x10000);
+#endif
+
+	VERBOSE(("exception: -------------------------------------------------------------- start"));
 	VERBOSE(("exception: %s, error_code = %x at %04x:%08x", exception_str[num], error_code, CPU_CS, CPU_PREV_EIP));
-	VERBOSE(("exception:------------------------------------------------"));
 	VERBOSE(("%s", cpu_reg2str()));
-	VERBOSE(("exception:------------------------------------------------"));
 
-	CPU_STAT_NERROR++;
-	if ((CPU_STAT_NERROR >= 3) 
-	 || (CPU_STAT_NERROR == 2 && CPU_STAT_PREV_EXCEPTION == DF_EXCEPTION)) {
+	CPU_STAT_EXCEPTION_COUNTER_INC();
+	if ((CPU_STAT_EXCEPTION_COUNTER >= 3) 
+	 || (CPU_STAT_EXCEPTION_COUNTER == 2 && CPU_STAT_PREV_EXCEPTION == DF_EXCEPTION)) {
 		/* Triple fault */
 		ia32_panic("exception: catch triple fault!");
 	}
 
 	switch (num) {
 	case DE_EXCEPTION:	/* (F) 除算エラー */
+	case DB_EXCEPTION:	/* (F/T) デバッグ */
 	case BR_EXCEPTION:	/* (F) BOUND の範囲外 */
 	case UD_EXCEPTION:	/* (F) 無効オペコード */
 	case NM_EXCEPTION:	/* (F) デバイス使用不可 (FPU が無い) */
+	case MF_EXCEPTION:	/* (F) 浮動小数点エラー */
 		CPU_EIP = CPU_PREV_EIP;
 		/*FALLTHROUGH*/
-	case DB_EXCEPTION:	/* (F/T) デバッグ */
 	case NMI_EXCEPTION:	/* (I) NMI 割り込み */
 	case BP_EXCEPTION:	/* (T) ブレークポイント */
 	case OF_EXCEPTION:	/* (T) オーバーフロー */
@@ -115,34 +116,37 @@ exception(int num, int error_code)
 		errorp = 1;
 		break;
 
-	case MF_EXCEPTION:	/* (F) 浮動小数点エラー */
-		CPU_EIP = CPU_PREV_EIP;
-		errorp = 0;
-		break;
-
-	case MC_EXCEPTION:	/* (A) マシンチェック */
-		CPU_EIP = CPU_PREV_EIP;
-		errorp = 0;
-		break;
-
-	case XF_EXCEPTION:	/* (F) ストリーミング SIMD 拡張命令 */
-		CPU_EIP = CPU_PREV_EIP;
-		errorp = 0;
-		break;
-
 	default:
 		ia32_panic("exception: unknown exception (%d)", num);
 		break;
 	}
 
-	if (CPU_STAT_NERROR >= 2) {
+	if (CPU_STATSAVE.cpu_stat.backout_sp) {
+		VERBOSE(("exception: restore stack pointer."));
+		CPU_ESP = CPU_PREV_ESP;
+		CPU_STATSAVE.cpu_stat.backout_sp = 0;
+	}
+
+	if (CPU_STAT_EXCEPTION_COUNTER >= 2) {
 		if (dftable[exctype[CPU_STAT_PREV_EXCEPTION]][exctype[num]]) {
 			num = DF_EXCEPTION;
+			errorp = 1;
+			error_code = 0;
 		}
 	}
 	CPU_STAT_PREV_EXCEPTION = num;
 
-	INTERRUPT(num, FALSE, errorp, error_code);
+	VERBOSE(("exception: ---------------------------------------------------------------- end"));
+
+	interrupt(num, 0, errorp, error_code);
+#if defined(IA32_SUPPORT_DEBUG_REGISTER)
+	if (num != BP_EXCEPTION) {
+		if (CPU_INST_OP32) {
+			set_eflags(REAL_EFLAGREG|RF_FLAG, RF_FLAG);
+		}
+	}
+#endif
+	CPU_STAT_EXCEPTION_COUNTER_CLEAR();
 	siglongjmp(exec_1step_jmpbuf, 1);
 }
 
@@ -202,32 +206,33 @@ exception(int num, int error_code)
  * D          : ゲートのサイズ．0 = 16 bit, 1 = 32 bit
  */
 
-static void interrupt_task(descriptor_t *gdp, int softintp, int errorp, int error_code);
-static void interrupt_intr_or_trap(descriptor_t *gdp, int softintp, int errorp, int error_code);
+static void interrupt_task_gate(const descriptor_t *gsdp, int intrtype, int errorp, int error_code);
+static void interrupt_intr_or_trap(const descriptor_t *gsdp, int intrtype, int errorp, int error_code);
 
 void
-interrupt(int num, int softintp, int errorp, int error_code)
+interrupt(int num, int intrtype, int errorp, int error_code)
 {
-	descriptor_t gd;
-	DWORD idt_idx;
-	DWORD new_ip;
-	WORD new_cs;
+	descriptor_t gsd;
+	UINT idt_idx;
+	UINT32 new_ip;
+	UINT16 new_cs;
+	int exc_errcode;
 
-	VERBOSE(("interrupt: num = 0x%02x, softintp = %s, errorp = %s, error_code = %02x", num, softintp ? "on" : "off", errorp ? "on" : "off", error_code));
+	VERBOSE(("interrupt: num = 0x%02x, intrtype = %s, errorp = %s, error_code = %08x", num, intrtype ? "on" : "off", errorp ? "on" : "off", error_code));
 
 	if (!CPU_STAT_PM) {
 		/* real mode */
+		CPU_WORKCLOCK(20);
+
 		idt_idx = num * 4;
 		if (idt_idx + 3 > CPU_IDTR_LIMIT) {
 			VERBOSE(("interrupt: real-mode IDTR limit check failure (idx = 0x%04x, limit = 0x%08x", idt_idx, CPU_IDTR_LIMIT));
-			EXCEPTION(GP_EXCEPTION, num * 4 | 2);
+			EXCEPTION(GP_EXCEPTION, idt_idx + 2);
 		}
 
-		if (!softintp) {
-			BYTE op = cpu_codefetch(CPU_IP);
-			if (op == 0xf4)	{	/* hlt */
-				CPU_EIP++;
-			}
+		if ((intrtype == INTR_TYPE_EXTINTR) && CPU_STAT_HLT) {
+			CPU_EIP++;
+			CPU_STAT_HLT = 0;
 		}
 
 		REGPUSH0(REAL_FLAGREG);
@@ -237,34 +242,47 @@ interrupt(int num, int softintp, int err
 		CPU_EFLAG &= ~(T_FLAG | I_FLAG | AC_FLAG | RF_FLAG);
 		CPU_TRAP = 0;
 
-		new_ip = cpu_memoryread_w(CPU_IDTR_BASE + num * 4);
-		new_cs = cpu_memoryread_w(CPU_IDTR_BASE + num * 4 + 2);
-		CPU_SET_SEGREG(CPU_CS_INDEX, new_cs);
-		SET_EIP(new_ip);
-		CPU_WORKCLOCK(20);
+		new_ip = cpu_memoryread_w(CPU_IDTR_BASE + idt_idx);
+		new_cs = cpu_memoryread_w(CPU_IDTR_BASE + idt_idx + 2);
+		LOAD_SEGREG(CPU_CS_INDEX, new_cs);
+		CPU_EIP = new_ip;
 	} else {
 		/* protected mode */
+		CPU_WORKCLOCK(200);
 
-		/* VM86 && IOPL < 3 && interrupt cause == INTn */
-		if (CPU_STAT_VM86 && (CPU_STAT_IOPL < CPU_IOPL3) && (softintp == -1)) {
-			VERBOSE(("interrupt: VM86 && IOPL < 3 && INTn"));
-			EXCEPTION(GP_EXCEPTION, 0);
+		VERBOSE(("interrupt: -------------------------------------------------------------- start"));
+		VERBOSE(("interrupt: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
+
+#if defined(DEBUG)
+		if (num == 0x80) {
+			/* Linux, FreeBSD, NetBSD, OpenBSD system call */
+			VERBOSE(("interrupt: syscall# = %d\n%s", CPU_EAX, cpu_reg2str()));
 		}
+#endif
 
 		idt_idx = num * 8;
+		exc_errcode = idt_idx + 2;
+		if (intrtype == INTR_TYPE_EXTINTR)
+			exc_errcode++;
+
 		if (idt_idx + 7 > CPU_IDTR_LIMIT) {
 			VERBOSE(("interrupt: IDTR limit check failure (idx = 0x%04x, limit = 0x%08x", idt_idx, CPU_IDTR_LIMIT));
-			EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp);
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 		}
 
-		memset(&gd, 0, sizeof(gd));
-		CPU_SET_GATEDESC(&gd, CPU_IDTR_BASE + idt_idx);
-		if (!gd.valid || !gd.p) {
+		/* load a gate descriptor from interrupt descriptor table */
+		memset(&gsd, 0, sizeof(gsd));
+		load_descriptor(&gsd, CPU_IDTR_BASE + idt_idx);
+		if (!SEG_IS_VALID(&gsd)) {
 			VERBOSE(("interrupt: gate descripter is invalid."));
-			EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp);
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
+		}
+		if (!SEG_IS_SYSTEM(&gsd)) {
+			VERBOSE(("interrupt: gate descriptor is not system segment."));
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 		}
 
-		switch (gd.type) {
+		switch (gsd.type) {
 		case CPU_SYSDESC_TYPE_TASK:
 		case CPU_SYSDESC_TYPE_INTR_16:
 		case CPU_SYSDESC_TYPE_INTR_32:
@@ -273,49 +291,59 @@ interrupt(int num, int softintp, int err
 			break;
 
 		default:
-			VERBOSE(("interrupt: invalid gate type (%d)", gd.type));
-			EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp);
+			VERBOSE(("interrupt: invalid gate type (%d)", gsd.type));
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 			break;
 		}
 
 		/* 5.10.1.1. 例外／割り込みハンドラ・プロシージャの保護 */
-		if (softintp && (gd.dpl < CPU_STAT_CPL)) {
-			VERBOSE(("interrupt: softintp && DPL(%d) < CPL(%d)", gd.dpl, CPU_STAT_CPL));
-			EXCEPTION(GP_EXCEPTION, num * 8 | 2);
+		if ((intrtype != INTR_TYPE_EXTINTR) && (gsd.dpl < CPU_STAT_CPL)) {
+			VERBOSE(("interrupt: intrtype(%d) && DPL(%d) < CPL(%d)", intrtype, gsd.dpl, CPU_STAT_CPL));
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
+		}
+
+		if (!SEG_IS_PRESENT(&gsd)) {
+			VERBOSE(("interrupt: gate descriptor is not present."));
+			EXCEPTION(NP_EXCEPTION, exc_errcode);
 		}
 
-		switch (gd.type) {
+		if ((intrtype == INTR_TYPE_EXTINTR) && CPU_STAT_HLT) {
+			CPU_EIP++;
+			CPU_STAT_HLT = 0;
+		}
+
+		switch (gsd.type) {
 		case CPU_SYSDESC_TYPE_TASK:
-			interrupt_task(&gd, softintp, errorp, error_code);
+			interrupt_task_gate(&gsd, intrtype, errorp, error_code);
 			break;
 
 		case CPU_SYSDESC_TYPE_INTR_16:
 		case CPU_SYSDESC_TYPE_INTR_32:
 		case CPU_SYSDESC_TYPE_TRAP_16:
 		case CPU_SYSDESC_TYPE_TRAP_32:
-			interrupt_intr_or_trap(&gd, softintp, errorp, error_code);
+			interrupt_intr_or_trap(&gsd, intrtype, errorp, error_code);
 			break;
 
 		default:
-			EXCEPTION(GP_EXCEPTION, num * 8 | 2 | !softintp);
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 			break;
 		}
+
+		VERBOSE(("interrupt: ---------------------------------------------------------------- end"));
 	}
 }
 
 static void
-interrupt_task(descriptor_t *gdp, int softintp, int errorp, int error_code)
+interrupt_task_gate(const descriptor_t *gsdp, int intrtype, int errorp, int error_code)
 {
 	selector_t task_sel;
 	int rv;
 
 	VERBOSE(("interrupt: TASK-GATE"));
 
-	(void)softintp;
-
-	rv = parse_selector(&task_sel, gdp->u.gate.selector);
-	if (rv < 0 || task_sel.ldt) {
-		VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d, %cDT)", gdp->u.gate.selector, rv, task_sel.ldt ? 'L' : 'G'));
+	rv = parse_selector(&task_sel, gsdp->u.gate.selector);
+	if (rv < 0 || task_sel.ldt || !SEG_IS_SYSTEM(&task_sel.desc)) {
+		VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d, %cDT, type = %s)", gsdp->u.gate.selector, rv, task_sel.ldt ? 'L' : 'G', task_sel.desc.s ? "code/data" : "system"));
 		EXCEPTION(TS_EXCEPTION, task_sel.idx);
 	}
 
@@ -349,176 +377,174 @@ interrupt_task(descriptor_t *gdp, int so
 }
 
 static void
-interrupt_intr_or_trap(descriptor_t *gdp, int softintp, int errorp, int error_code)
+interrupt_intr_or_trap(const descriptor_t *gsdp, int intrtype, int errorp, int error_code)
 {
-	selector_t intr_sel, ss_sel;
-	DWORD old_flags = REAL_EFLAGREG;
-	DWORD flags = REAL_EFLAGREG;
-	DWORD mask = 0;
-	DWORD stacksize;
-	DWORD new_ip, new_sp;
-	DWORD old_ip, old_sp;
-	WORD old_cs, old_ss, new_ss;
+	selector_t cs_sel, ss_sel;
+	UINT stacksize;
+	UINT32 old_flags;
+	UINT32 new_flags;
+	UINT32 mask;
+	UINT32 sp;
+	UINT32 new_ip, new_sp;
+	UINT32 old_ip, old_sp;
+	UINT16 old_cs, old_ss, new_ss;
+	int exc_errcode;
 	int rv; 
 
-	VERBOSE(("interrupt: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP));
-
-	new_ip = gdp->u.gate.offset;
+	new_ip = gsdp->u.gate.offset;
 	old_ss = CPU_SS;
 	old_cs = CPU_CS;
 	old_ip = CPU_EIP;
 	old_sp = CPU_ESP;
+	old_flags = REAL_EFLAGREG;
+	new_flags = REAL_EFLAGREG & ~(T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG);
+	mask = T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG;
 
-	switch (gdp->type) {
+	switch (gsdp->type) {
 	case CPU_SYSDESC_TYPE_INTR_16:
-		old_ip &= 0xffff;
-		old_sp &= 0xffff;
-		/*FALLTHROUGH*/
 	case CPU_SYSDESC_TYPE_INTR_32:
 		VERBOSE(("interrupt: INTERRUPT-GATE"));
-		flags &= ~I_FLAG;
+		new_flags &= ~I_FLAG;
 		mask |= I_FLAG;
 		break;
 
 	case CPU_SYSDESC_TYPE_TRAP_16:
-		old_ip &= 0xffff;
-		old_sp &= 0xffff;
-		/*FALLTHROUGH*/
 	case CPU_SYSDESC_TYPE_TRAP_32:
 		VERBOSE(("interrupt: TRAP-GATE"));
 		break;
+
+	default:
+		ia32_panic("interrupt: gate descriptor type is invalid (type = %d)", gsdp->type);
+		break;
 	}
-	flags &= ~(T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG);
-	mask |= T_FLAG|RF_FLAG|NT_FLAG|VM_FLAG;
 
-	rv = parse_selector(&intr_sel, gdp->u.gate.selector);
+	exc_errcode = cs_sel.idx;
+	if (intrtype == INTR_TYPE_EXTINTR)
+		exc_errcode++;
+
+	rv = parse_selector(&cs_sel, gsdp->u.gate.selector);
 	if (rv < 0) {
-		VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", gdp->u.gate.selector, rv));
-		EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp);
+		VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", gsdp->u.gate.selector, rv));
+		EXCEPTION(GP_EXCEPTION, exc_errcode);
 	}
 
 	/* check segment type */
-	if (!intr_sel.desc.s) {
+	if (SEG_IS_SYSTEM(&cs_sel.desc)) {
 		VERBOSE(("interrupt: code segment is system segment"));
-		EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp);
+		EXCEPTION(GP_EXCEPTION, exc_errcode);
 	}
-	if (!intr_sel.desc.u.seg.c) {
+	if (SEG_IS_DATA(&cs_sel.desc)) {
 		VERBOSE(("interrupt: code segment is data segment"));
-		EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp);
+		EXCEPTION(GP_EXCEPTION, exc_errcode);
 	}
 
 	/* check privilege level */
-	if (intr_sel.desc.dpl > CPU_STAT_CPL) {
-		VERBOSE(("interrupt: DPL(%d) > CPL(%d)", intr_sel.desc.dpl, CPU_STAT_CPL));
-		EXCEPTION(GP_EXCEPTION, intr_sel.idx | !softintp);
+	if (cs_sel.desc.dpl > CPU_STAT_CPL) {
+		VERBOSE(("interrupt: DPL(%d) > CPL(%d)", cs_sel.desc.dpl, CPU_STAT_CPL));
+		EXCEPTION(GP_EXCEPTION, exc_errcode);
 	}
 
 	/* not present */
-	if (selector_is_not_present(&intr_sel)) {
+	if (selector_is_not_present(&cs_sel)) {
 		VERBOSE(("interrupt: selector is not present"));
-		EXCEPTION(NP_EXCEPTION, intr_sel.idx | !softintp);
+		EXCEPTION(NP_EXCEPTION, exc_errcode);
 	}
 
-	if (!intr_sel.desc.u.seg.ec
-	 && (intr_sel.desc.dpl < CPU_STAT_CPL)) {
+	if (!SEG_IS_CONFORMING_CODE(&cs_sel.desc) && (cs_sel.desc.dpl < CPU_STAT_CPL)) {
+		stacksize = errorp ? 12 : 10;
 		if (!CPU_STAT_VM86) {
 			VERBOSE(("interrupt: INTER-PRIVILEGE-LEVEL-INTERRUPT"));
-			stacksize = errorp ? 12 : 10;
 		} else {
 			/* VM86 */
-			if (intr_sel.desc.dpl != 0) {
+			VERBOSE(("interrupt: INTERRUPT-FROM-VIRTUAL-8086-MODE"));
+			if (cs_sel.desc.dpl != 0) {
 				/* 16.3.1.1 */
-				VERBOSE(("interrupt: DPL[CS](%d) != 0", intr_sel.desc.dpl));
-				EXCEPTION(GP_EXCEPTION, intr_sel.idx);
+				VERBOSE(("interrupt: DPL[CS](%d) != 0", cs_sel.desc.dpl));
+				EXCEPTION(GP_EXCEPTION, exc_errcode);
 			}
-			VERBOSE(("interrupt: INTERRUPT-FROM-VIRTUAL-8086-MODE"));
-			stacksize = errorp ? 20 : 18;
+			stacksize += 8;
 		}
-		switch (gdp->type) {
-		case CPU_SYSDESC_TYPE_INTR_32:
-		case CPU_SYSDESC_TYPE_TRAP_32:
+		if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) {
 			stacksize *= 2;
-			break;
 		}
 
-		get_stack_from_tss(intr_sel.desc.dpl, &new_ss, &new_sp);
+		/* get stack pointer from TSS */
+		get_stack_pointer_from_tss(cs_sel.desc.dpl, &new_ss, &new_sp);
 
+		/* parse stack segment descriptor */
 		rv = parse_selector(&ss_sel, new_ss);
+
+		/* update exception error code */
+		exc_errcode = ss_sel.idx;
+		if (intrtype == INTR_TYPE_EXTINTR)
+			exc_errcode++;
+
 		if (rv < 0) {
 			VERBOSE(("interrupt: parse_selector (selector = %04x, rv = %d)", new_ss, rv));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
 
 		/* check privilege level */
-		if (ss_sel.rpl != intr_sel.desc.dpl) {
-			VERBOSE(("interrupt: RPL[SS](%d) != DPL[CS](%d)", ss_sel.rpl, intr_sel.desc.dpl));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+		if (ss_sel.rpl != cs_sel.desc.dpl) {
+			VERBOSE(("interrupt: selector RPL[SS](%d) != DPL[CS](%d)", ss_sel.rpl, cs_sel.desc.dpl));
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
-		if (ss_sel.desc.dpl != intr_sel.desc.dpl) {
-			VERBOSE(("interrupt: DPL[SS](%d) != DPL[CS](%d)", ss_sel.desc.dpl, intr_sel.desc.dpl));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+		if (ss_sel.desc.dpl != cs_sel.desc.dpl) {
+			VERBOSE(("interrupt: descriptor DPL[SS](%d) != DPL[CS](%d)", ss_sel.desc.dpl, cs_sel.desc.dpl));
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
 
-		/* check segment type */
-		if (!ss_sel.desc.s) {
+		/* stack segment must be writable data segment. */
+		if (SEG_IS_SYSTEM(&ss_sel.desc)) {
 			VERBOSE(("interrupt: stack segment is system segment"));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
-		if (ss_sel.desc.u.seg.c) {
+		if (SEG_IS_CODE(&ss_sel.desc)) {
 			VERBOSE(("interrupt: stack segment is code segment"));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
-		if (!ss_sel.desc.u.seg.wr) {
+		if (!SEG_IS_WRITABLE_DATA(&ss_sel.desc)) {
 			VERBOSE(("interrupt: stack segment is read-only data segment"));
-			EXCEPTION(TS_EXCEPTION, ss_sel.idx | !softintp);
+			EXCEPTION(TS_EXCEPTION, exc_errcode);
 		}
 
 		/* not present */
 		if (selector_is_not_present(&ss_sel)) {
 			VERBOSE(("interrupt: selector is not present"));
-			EXCEPTION(SS_EXCEPTION, ss_sel.idx | !softintp);
+			EXCEPTION(SS_EXCEPTION, exc_errcode);
 		}
 
 		/* check stack room size */
-		CHECK_STACK_PUSH(&ss_sel.desc, new_sp, stacksize);
+		cpu_stack_push_check(ss_sel.idx, &ss_sel.desc, new_sp, stacksize);
 
 		/* out of range */
-		if (new_ip > intr_sel.desc.u.seg.limit) {
-			VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, intr_sel.desc.u.seg.limit));
+		if (new_ip > cs_sel.desc.u.seg.limit) {
+			VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, cs_sel.desc.u.seg.limit));
 			EXCEPTION(GP_EXCEPTION, 0);
 		}
 
-		load_ss(ss_sel.selector, &ss_sel.desc, intr_sel.desc.dpl);
+		load_ss(ss_sel.selector, &ss_sel.desc, cs_sel.desc.dpl);
 		CPU_ESP = new_sp;
 
-		load_cs(intr_sel.selector, &intr_sel.desc, intr_sel.desc.dpl);
-		SET_EIP(new_ip);
+		load_cs(cs_sel.selector, &cs_sel.desc, cs_sel.desc.dpl);
+		CPU_EIP = new_ip;
 
-		if (CPU_STAT_VM86) {
-			switch (gdp->type) {
-			case CPU_SYSDESC_TYPE_INTR_32:
-			case CPU_SYSDESC_TYPE_TRAP_32:
+		if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) {
+			if (CPU_STAT_VM86) {
 				PUSH0_32(CPU_GS);
 				PUSH0_32(CPU_FS);
 				PUSH0_32(CPU_DS);
 				PUSH0_32(CPU_ES);
-				break;
 
-			case CPU_SYSDESC_TYPE_INTR_16:
-			case CPU_SYSDESC_TYPE_TRAP_16:
-				ia32_panic("interrupt: 16bit gate");
-				break;
+				LOAD_SEGREG(CPU_GS_INDEX, 0);
+				CPU_STAT_SREG(CPU_GS_INDEX).valid = 0;
+				LOAD_SEGREG(CPU_FS_INDEX, 0);
+				CPU_STAT_SREG(CPU_FS_INDEX).valid = 0;
+				LOAD_SEGREG(CPU_DS_INDEX, 0);
+				CPU_STAT_SREG(CPU_DS_INDEX).valid = 0;
+				LOAD_SEGREG(CPU_ES_INDEX, 0);
+				CPU_STAT_SREG(CPU_ES_INDEX).valid = 0;
 			}
-
-			CPU_SET_SEGREG(CPU_GS_INDEX, 0);
-			CPU_SET_SEGREG(CPU_FS_INDEX, 0);
-			CPU_SET_SEGREG(CPU_DS_INDEX, 0);
-			CPU_SET_SEGREG(CPU_ES_INDEX, 0);
-		}
-
-		switch (gdp->type) {
-		case CPU_SYSDESC_TYPE_INTR_32:
-		case CPU_SYSDESC_TYPE_TRAP_32:
 			PUSH0_32(old_ss);
 			PUSH0_32(old_sp);
 			PUSH0_32(old_flags);
@@ -527,10 +553,10 @@ interrupt_intr_or_trap(descriptor_t *gdp
 			if (errorp) {
 				PUSH0_32(error_code);
 			}
-			break;
-
-		case CPU_SYSDESC_TYPE_INTR_16:
-		case CPU_SYSDESC_TYPE_TRAP_16:
+		} else {
+			if (CPU_STAT_VM86) {
+				ia32_panic("interrupt: 16bit gate && VM86");
+			}
 			PUSH0_16(old_ss);
 			PUSH0_16(old_sp);
 			PUSH0_16(old_flags);
@@ -539,69 +565,58 @@ interrupt_intr_or_trap(descriptor_t *gdp
 			if (errorp) {
 				PUSH0_16(error_code);
 			}
-			break;
 		}
-
-		set_eflags(flags, mask);
 	} else {
 		if (CPU_STAT_VM86) {
 			VERBOSE(("interrupt: VM86"));
-			EXCEPTION(GP_EXCEPTION, intr_sel.idx);
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 		}
-		if (!intr_sel.desc.u.seg.ec && (intr_sel.desc.dpl != CPU_STAT_CPL)) {
-			VERBOSE(("interrupt: NON-CONFORMING-CODE-SEGMENT(%s) and DPL[CS](%d) != CPL", intr_sel.desc.u.seg.ec ? "false" : "true", intr_sel.desc.dpl, CPU_STAT_CPL));
-			EXCEPTION(GP_EXCEPTION, intr_sel.idx);
+		if (!SEG_IS_CONFORMING_CODE(&cs_sel.desc) && (cs_sel.desc.dpl != CPU_STAT_CPL)) {
+			VERBOSE(("interrupt: %sCONFORMING-CODE-SEGMENT(%s) && DPL[CS](%d) != CPL", SEG_IS_CONFORMING_CODE(&cs_sel.desc) ? "" : "NON-", cs_sel.desc.dpl, CPU_STAT_CPL));
+			EXCEPTION(GP_EXCEPTION, exc_errcode);
 		}
-		VERBOSE(("interrupt: INTRA-PRIVILEGE-LEVEL-INTERRUPT"));
 
-		if (CPU_STAT_SS32) {
-			new_sp = CPU_ESP;
-		} else {
-			new_sp = CPU_SP;
-		}
+		VERBOSE(("interrupt: INTRA-PRIVILEGE-LEVEL-INTERRUPT"));
 
 		stacksize = errorp ? 8 : 6;
-		switch (gdp->type) {
-		case CPU_SYSDESC_TYPE_INTR_32:
-		case CPU_SYSDESC_TYPE_TRAP_32:
+		if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) {
 			stacksize *= 2;
-			break;
 		}
-		CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), new_sp, stacksize);
+
+		/* check stack room size */
+		if (CPU_STAT_SS32) {
+			sp = CPU_ESP;
+		} else {
+			sp = CPU_SP;
+		}
+		SS_PUSH_CHECK(sp, stacksize);
 
 		/* out of range */
-		if (new_ip > intr_sel.desc.u.seg.limit) {
-			VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, intr_sel.desc.u.seg.limit));
+		if (new_ip > cs_sel.desc.u.seg.limit) {
+			VERBOSE(("interrupt: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, cs_sel.desc.u.seg.limit));
 			EXCEPTION(GP_EXCEPTION, 0);
 		}
 
-		switch (gdp->type) {
-		case CPU_SYSDESC_TYPE_INTR_32:
-		case CPU_SYSDESC_TYPE_TRAP_32:
-			PUSH0_32(REAL_EFLAGREG);
-			PUSH0_32(CPU_CS);
-			PUSH0_32(CPU_EIP);
+		load_cs(cs_sel.selector, &cs_sel.desc, CPU_STAT_CPL);
+		CPU_EIP = new_ip;
+
+		if (gsdp->type & CPU_SYSDESC_TYPE_32BIT) {
+			PUSH0_32(old_flags);
+			PUSH0_32(old_cs);
+			PUSH0_32(old_ip);
 			if (errorp) {
 				PUSH0_32(error_code);
 			}
-			break;
-
-		case CPU_SYSDESC_TYPE_INTR_16:
-		case CPU_SYSDESC_TYPE_TRAP_16:
-			PUSH0_16(REAL_FLAGREG);
-			PUSH0_16(CPU_CS);
-			PUSH0_16(CPU_IP);
+		} else {
+			PUSH0_16(old_flags);
+			PUSH0_16(old_cs);
+			PUSH0_16(old_ip);
 			if (errorp) {
 				PUSH0_16(error_code);
 			}
-			break;
 		}
-
-		load_cs(intr_sel.selector, &intr_sel.desc, CPU_STAT_CPL);
-		SET_EIP(new_ip);
-
-		set_eflags(flags, mask);
 	}
+	set_eflags(new_flags, mask);
 
-	VERBOSE(("interrupt: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
+	VERBOSE(("interrupt: new EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
 }