[ViewVC] Diff of: cebix/BasiliskII/src/Unix/sigsegv.cpp

Comparing BasiliskII/src/Unix/sigsegv.cpp (file contents):
Revision 1.33 by gbeauche, 2003-10-21T23:10:19Z vs.
Revision 1.34 by gbeauche, 2003-11-10T23:47:39Z

#	Line 69 \| Line 69 \| static bool sigsegv_do_install_handler(i
69		enum transfer_size_t {
70		SIZE_UNKNOWN,
71		SIZE_BYTE,
72	<	SIZE_WORD,
73	<	SIZE_LONG
72	>	SIZE_WORD, // 2 bytes
73	>	SIZE_LONG, // 4 bytes
74	>	SIZE_QUAD, // 8 bytes
75		};
76
77		// Transfer type
#	Line 231 \| Line 232 \| static void powerpc_decode_instruction(i
232		#if defined(__FreeBSD__)
233		#if (defined(i386) \|\| defined(__i386__))
234		#define SIGSEGV_FAULT_INSTRUCTION (((struct sigcontext *)scp)->sc_eip)
235	<	#define SIGSEGV_REGISTER_FILE ((unsigned int )&(((struct sigcontext )scp)->sc_edi)) /* EDI is the first GPR (even below EIP) in sigcontext */
235	>	#define SIGSEGV_REGISTER_FILE ((unsigned long )&(((struct sigcontext )scp)->sc_edi)) /* EDI is the first GPR (even below EIP) in sigcontext */
236		#define SIGSEGV_SKIP_INSTRUCTION ix86_skip_instruction
237		#endif
238		#endif
#	Line 240 \| Line 241 \| static void powerpc_decode_instruction(i
241		#include <sys/ucontext.h>
242		#define SIGSEGV_CONTEXT_REGS (((ucontext_t *)scp)->uc_mcontext.gregs)
243		#define SIGSEGV_FAULT_INSTRUCTION SIGSEGV_CONTEXT_REGS[14] /* should use REG_EIP instead */
244	<	#define SIGSEGV_REGISTER_FILE (unsigned int *)SIGSEGV_CONTEXT_REGS
244	>	#define SIGSEGV_REGISTER_FILE (unsigned long *)SIGSEGV_CONTEXT_REGS
245		#define SIGSEGV_SKIP_INSTRUCTION ix86_skip_instruction
246		#endif
247		#if (defined(x86_64) \|\| defined(__x86_64__))
#	Line 248 \| Line 249 \| static void powerpc_decode_instruction(i
249		#define SIGSEGV_CONTEXT_REGS (((ucontext_t *)scp)->uc_mcontext.gregs)
250		#define SIGSEGV_FAULT_INSTRUCTION SIGSEGV_CONTEXT_REGS[16] /* should use REG_RIP instead */
251		#define SIGSEGV_REGISTER_FILE (unsigned long *)SIGSEGV_CONTEXT_REGS
252	+	#define SIGSEGV_SKIP_INSTRUCTION ix86_skip_instruction
253		#endif
254		#if (defined(ia64) \|\| defined(__ia64__))
255		#define SIGSEGV_FAULT_INSTRUCTION (((struct sigcontext )scp)->sc_ip & ~0x3ULL) / slot number is in bits 0 and 1 */
#	Line 273 \| Line 275 \| static void powerpc_decode_instruction(i
275		#define SIGSEGV_FAULT_HANDLER_ARGS &scs
276		#define SIGSEGV_FAULT_ADDRESS scp->cr2
277		#define SIGSEGV_FAULT_INSTRUCTION scp->eip
278	<	#define SIGSEGV_REGISTER_FILE (unsigned int *)scp
278	>	#define SIGSEGV_REGISTER_FILE (unsigned long *)scp
279		#define SIGSEGV_SKIP_INSTRUCTION ix86_skip_instruction
280		#endif
281		#if (defined(sparc) \|\| defined(__sparc__))
#	Line 384 \| Line 386 \| static sigsegv_address_t get_fault_addre
386		#define SIGSEGV_FAULT_HANDLER_ARGS sig, code, scp, addr
387		#define SIGSEGV_FAULT_ADDRESS addr
388		#define SIGSEGV_FAULT_INSTRUCTION scp->sc_eip
389	<	#define SIGSEGV_REGISTER_FILE ((unsigned int *)&scp->sc_edi)
389	>	#define SIGSEGV_REGISTER_FILE ((unsigned long *)&scp->sc_edi)
390		#define SIGSEGV_SKIP_INSTRUCTION ix86_skip_instruction
391		#endif
392		#endif
#	Line 577 \| Line 579 \| *handleExceptions(void priv)**
579
580		#ifdef HAVE_SIGSEGV_SKIP_INSTRUCTION
581		// Decode and skip X86 instruction
582	<	#if (defined(i386) \|\| defined(__i386__))
582	>	#if (defined(i386) \|\| defined(__i386__)) \|\| defined(__x86_64__)
583		#if defined(__linux__)
584		enum {
585	+	#if (defined(i386) \|\| defined(__i386__))
586		X86_REG_EIP = 14,
587		X86_REG_EAX = 11,
588		X86_REG_ECX = 10,
#	Line 589 \| Line 592 \| enum {
592		X86_REG_EBP = 6,
593		X86_REG_ESI = 5,
594		X86_REG_EDI = 4
595	+	#endif
596	+	#if defined(__x86_64__)
597	+	X86_REG_R8 = 0,
598	+	X86_REG_R9 = 1,
599	+	X86_REG_R10 = 2,
600	+	X86_REG_R11 = 3,
601	+	X86_REG_R12 = 4,
602	+	X86_REG_R13 = 5,
603	+	X86_REG_R14 = 6,
604	+	X86_REG_R15 = 7,
605	+	X86_REG_EDI = 8,
606	+	X86_REG_ESI = 9,
607	+	X86_REG_EBP = 10,
608	+	X86_REG_EBX = 11,
609	+	X86_REG_EDX = 12,
610	+	X86_REG_EAX = 13,
611	+	X86_REG_ECX = 14,
612	+	X86_REG_ESP = 15,
613	+	X86_REG_EIP = 16
614	+	#endif
615		};
616		#endif
617		#if defined(__NetBSD__) \|\| defined(__FreeBSD__)
618		enum {
619	+	#if (defined(i386) \|\| defined(__i386__))
620		X86_REG_EIP = 10,
621		X86_REG_EAX = 7,
622		X86_REG_ECX = 6,
#	Line 602 \| Line 626 \| enum {
626		X86_REG_EBP = 2,
627		X86_REG_ESI = 1,
628		X86_REG_EDI = 0
629	+	#endif
630		};
631		#endif
632		// FIXME: this is partly redundant with the instruction decoding phase
#	Line 638 \| Line 663 \| static inline int ix86_step_over_modrm(u
663		return offset;
664		}
665
666	<	static bool ix86_skip_instruction(unsigned int * regs)
666	>	static bool ix86_skip_instruction(unsigned long * regs)
667		{
668		unsigned char * eip = (unsigned char *)regs[X86_REG_EIP];
669
#	Line 650 \| Line 675 \| static bool ix86_skip_instruction(unsign
675
676		int reg = -1;
677		int len = 0;
678	<
678	>
679	>	#if DEBUG
680	>	printf("IP: %p [%02x %02x %02x %02x...]\n",
681	>	eip, eip[0], eip[1], eip[2], eip[3]);
682	>	#endif
683	>
684		// Operand size prefix
685		if (*eip == 0x66) {
686		eip++;
#	Line 658 \| Line 688 \| static bool ix86_skip_instruction(unsign
688		transfer_size = SIZE_WORD;
689		}
690
691	+	// REX prefix
692	+	#if defined(__x86_64__)
693	+	struct rex_t {
694	+	unsigned char W;
695	+	unsigned char R;
696	+	unsigned char X;
697	+	unsigned char B;
698	+	};
699	+	rex_t rex = { 0, 0, 0, 0 };
700	+	bool has_rex = false;
701	+	if ((*eip & 0xf0) == 0x40) {
702	+	has_rex = true;
703	+	const unsigned char b = *eip;
704	+	rex.W = b & (1 << 3);
705	+	rex.R = b & (1 << 2);
706	+	rex.X = b & (1 << 1);
707	+	rex.B = b & (1 << 0);
708	+	#if DEBUG
709	+	printf("REX: %c,%c,%c,%c\n",
710	+	rex.W ? 'W' : '_',
711	+	rex.R ? 'R' : '_',
712	+	rex.X ? 'X' : '_',
713	+	rex.B ? 'B' : '_');
714	+	#endif
715	+	eip++;
716	+	len++;
717	+	if (rex.W)
718	+	transfer_size = SIZE_QUAD;
719	+	}
720	+	#else
721	+	const bool has_rex = false;
722	+	#endif
723	+
724		// Decode instruction
725		switch (eip[0]) {
726		case 0x0f:
#	Line 727 \| Line 790 \| static bool ix86_skip_instruction(unsign
790		return false;
791		}
792
793	+	#if defined(__x86_64__)
794	+	if (rex.R)
795	+	reg += 8;
796	+	#endif
797	+
798		if (transfer_type == SIGSEGV_TRANSFER_LOAD && reg != -1) {
799	<	static const int x86_reg_map[8] = {
799	>	static const int x86_reg_map[] = {
800		X86_REG_EAX, X86_REG_ECX, X86_REG_EDX, X86_REG_EBX,
801	<	X86_REG_ESP, X86_REG_EBP, X86_REG_ESI, X86_REG_EDI
801	>	X86_REG_ESP, X86_REG_EBP, X86_REG_ESI, X86_REG_EDI,
802	>	#if defined(__x86_64__)
803	>	X86_REG_R8, X86_REG_R9, X86_REG_R10, X86_REG_R11,
804	>	X86_REG_R12, X86_REG_R13, X86_REG_R14, X86_REG_R15,
805	>	#endif
806		};
807
808	<	if (reg < 0 \|\| reg >= 8)
808	>	if (reg < 0 \|\| reg >= (sizeof(x86_reg_map)/sizeof(x86_reg_map[0]) - 1))
809		return false;
810
811	+	// Set 0 to the relevant register part
812	+	// NOTE: this is only valid for MOV alike instructions
813		int rloc = x86_reg_map[reg];
814		switch (transfer_size) {
815		case SIZE_BYTE:
816	<	regs[rloc] = (regs[rloc] & ~0xff);
816	>	if (!has_rex && reg >= 4)
817	>	regs[rloc - 4] = (regs[rloc - 4] & ~0xff00L);
818	>	else
819	>	regs[rloc] = (regs[rloc] & ~0xffL);
820		break;
821		case SIZE_WORD:
822	<	regs[rloc] = (regs[rloc] & ~0xffff);
822	>	regs[rloc] = (regs[rloc] & ~0xffffL);
823		break;
824		case SIZE_LONG:
825	+	case SIZE_QUAD: // zero-extension
826		regs[rloc] = 0;
827		break;
828		}
#	Line 752 \| Line 830 \| static bool ix86_skip_instruction(unsign
830
831		#if DEBUG
832		printf("%08x: %s %s access", regs[X86_REG_EIP],
833	<	transfer_size == SIZE_BYTE ? "byte" : transfer_size == SIZE_WORD ? "word" : "long",
833	>	transfer_size == SIZE_BYTE ? "byte" :
834	>	transfer_size == SIZE_WORD ? "word" :
835	>	transfer_size == SIZE_LONG ? "long" :
836	>	transfer_size == SIZE_QUAD ? "quad" : "unknown",
837		transfer_type == SIGSEGV_TRANSFER_LOAD ? "read" : "write");
838
839		if (reg != -1) {
840	<	static const char * x86_reg_str_map[8] = {
841	<	"eax", "ecx", "edx", "ebx",
842	<	"esp", "ebp", "esi", "edi"
840	>	static const char * x86_byte_reg_str_map[] = {
841	>	"al", "cl", "dl", "bl",
842	>	"spl", "bpl", "sil", "dil",
843	>	"r8b", "r9b", "r10b", "r11b",
844	>	"r12b", "r13b", "r14b", "r15b",
845	>	"ah", "ch", "dh", "bh",
846	>	};
847	>	static const char * x86_word_reg_str_map[] = {
848	>	"ax", "cx", "dx", "bx",
849	>	"sp", "bp", "si", "di",
850	>	"r8w", "r9w", "r10w", "r11w",
851	>	"r12w", "r13w", "r14w", "r15w",
852	>	};
853	>	static const char *x86_long_reg_str_map[] = {
854	>	"eax", "ecx", "edx", "ebx",
855	>	"esp", "ebp", "esi", "edi",
856	>	"r8d", "r9d", "r10d", "r11d",
857	>	"r12d", "r13d", "r14d", "r15d",
858	>	};
859	>	static const char *x86_quad_reg_str_map[] = {
860	>	"rax", "rcx", "rdx", "rbx",
861	>	"rsp", "rbp", "rsi", "rdi",
862	>	"r8", "r9", "r10", "r11",
863	>	"r12", "r13", "r14", "r15",
864		};
865	<	printf(" %s register %%%s", transfer_type == SIGSEGV_TRANSFER_LOAD ? "to" : "from", x86_reg_str_map[reg]);
865	>	const char * reg_str = NULL;
866	>	switch (transfer_size) {
867	>	case SIZE_BYTE:
868	>	reg_str = x86_byte_reg_str_map[(!has_rex && reg >= 4 ? 12 : 0) + reg];
869	>	break;
870	>	case SIZE_WORD: reg_str = x86_word_reg_str_map[reg]; break;
871	>	case SIZE_LONG: reg_str = x86_long_reg_str_map[reg]; break;
872	>	case SIZE_QUAD: reg_str = x86_quad_reg_str_map[reg]; break;
873	>	}
874	>	if (reg_str)
875	>	printf(" %s register %%%s",
876	>	transfer_type == SIGSEGV_TRANSFER_LOAD ? "to" : "from",
877	>	reg_str);
878		}
879		printf(", %d bytes instruction\n", len);
880		#endif
#	Line 1268 \| Line 1382 \| static sigsegv_return_t sigsegv_insn_han
1382
1383		return SIGSEGV_RETURN_FAILURE;
1384		}
1385	+
1386	+	// More sophisticated tests for instruction skipper
1387	+	static bool arch_insn_skipper_tests()
1388	+	{
1389	+	#if (defined(i386) \|\| defined(__i386__)) \|\| defined(__x86_64__)
1390	+	static const unsigned char code[] = {
1391	+	0x8a, 0x00, // mov (%eax),%al
1392	+	0x8a, 0x2c, 0x18, // mov (%eax,%ebx,1),%ch
1393	+	0x88, 0x20, // mov %ah,(%eax)
1394	+	0x88, 0x08, // mov %cl,(%eax)
1395	+	0x66, 0x8b, 0x00, // mov (%eax),%ax
1396	+	0x66, 0x8b, 0x0c, 0x18, // mov (%eax,%ebx,1),%cx
1397	+	0x66, 0x89, 0x00, // mov %ax,(%eax)
1398	+	0x66, 0x89, 0x0c, 0x18, // mov %cx,(%eax,%ebx,1)
1399	+	0x8b, 0x00, // mov (%eax),%eax
1400	+	0x8b, 0x0c, 0x18, // mov (%eax,%ebx,1),%ecx
1401	+	0x89, 0x00, // mov %eax,(%eax)
1402	+	0x89, 0x0c, 0x18, // mov %ecx,(%eax,%ebx,1)
1403	+	#if defined(__x86_64__)
1404	+	0x44, 0x8a, 0x00, // mov (%rax),%r8b
1405	+	0x44, 0x8a, 0x20, // mov (%rax),%r12b
1406	+	0x42, 0x8a, 0x3c, 0x10, // mov (%rax,%r10,1),%dil
1407	+	0x44, 0x88, 0x00, // mov %r8b,(%rax)
1408	+	0x44, 0x88, 0x20, // mov %r12b,(%rax)
1409	+	0x42, 0x88, 0x3c, 0x10, // mov %dil,(%rax,%r10,1)
1410	+	0x66, 0x44, 0x8b, 0x00, // mov (%rax),%r8w
1411	+	0x66, 0x42, 0x8b, 0x0c, 0x10, // mov (%rax,%r10,1),%cx
1412	+	0x66, 0x44, 0x89, 0x00, // mov %r8w,(%rax)
1413	+	0x66, 0x42, 0x89, 0x0c, 0x10, // mov %cx,(%rax,%r10,1)
1414	+	0x44, 0x8b, 0x00, // mov (%rax),%r8d
1415	+	0x42, 0x8b, 0x0c, 0x10, // mov (%rax,%r10,1),%ecx
1416	+	0x44, 0x89, 0x00, // mov %r8d,(%rax)
1417	+	0x42, 0x89, 0x0c, 0x10, // mov %ecx,(%rax,%r10,1)
1418	+	0x48, 0x8b, 0x08, // mov (%rax),%rcx
1419	+	0x4c, 0x8b, 0x18, // mov (%rax),%r11
1420	+	0x4a, 0x8b, 0x0c, 0x10, // mov (%rax,%r10,1),%rcx
1421	+	0x4e, 0x8b, 0x1c, 0x10, // mov (%rax,%r10,1),%r11
1422	+	0x48, 0x89, 0x08, // mov %rcx,(%rax)
1423	+	0x4c, 0x89, 0x18, // mov %r11,(%rax)
1424	+	0x4a, 0x89, 0x0c, 0x10, // mov %rcx,(%rax,%r10,1)
1425	+	0x4e, 0x89, 0x1c, 0x10, // mov %r11,(%rax,%r10,1)
1426	+	#endif
1427	+	0 // end
1428	+	};
1429	+	const int N_REGS = 20;
1430	+	unsigned long regs[N_REGS];
1431	+	for (int i = 0; i < N_REGS; i++)
1432	+	regs[i] = i;
1433	+	const unsigned long start_code = (unsigned long)&code;
1434	+	regs[X86_REG_EIP] = start_code;
1435	+	while ((regs[X86_REG_EIP] - start_code) < (sizeof(code) - 1)
1436	+	&& ix86_skip_instruction(regs))
1437	+	; /* simply iterate */
1438	+	return (regs[X86_REG_EIP] - start_code) == (sizeof(code) - 1);
1439	+	#endif
1440	+	return true;
1441	+	}
1442		#endif
1443
1444		int main(void)
#	Line 1314 \| Line 1485 \| int main(void)
1485		return 8;
1486
1487		#define TEST_SKIP_INSTRUCTION(TYPE) do { \
1488	<	const unsigned int TAG = 0x12345678; \
1488	>	const unsigned long TAG = 0x12345678 \| \
1489	>	(sizeof(long) == 8 ? 0x9abcdef0UL << 31 : 0); \
1490		TYPE data = ((TYPE )(page + sizeof(TYPE))); \
1491	<	volatile unsigned int effect = data + TAG; \
1491	>	volatile unsigned long effect = data + TAG; \
1492		if (effect != TAG) \
1493		return 9; \
1494		} while (0)
#	Line 1329 \| Line 1501 \| int main(void)
1501		TEST_SKIP_INSTRUCTION(unsigned char);
1502		TEST_SKIP_INSTRUCTION(unsigned short);
1503		TEST_SKIP_INSTRUCTION(unsigned int);
1504	+	TEST_SKIP_INSTRUCTION(unsigned long);
1505		L_e_region2:
1506		#endif
1507
1508	+	if (!arch_insn_skipper_tests())
1509	+	return 20;
1510	+
1511		vm_exit();
1512		return 0;
1513		}
1514		#endif
1339	–
1340	–
1341	–
1342	–
1343	–
1344	–
1345	–
1346	–
1347	–
1348	–
1349	–
1350	–
1351	–
1352	–
1353	–

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing BasiliskII/src/Unix/sigsegv.cpp (file contents): Revision 1.33 by gbeauche, 2003-10-21T23:10:19Z vs. Revision 1.34 by gbeauche, 2003-11-10T23:47:39Z

Diff Legend

Comparing BasiliskII/src/Unix/sigsegv.cpp (file contents):
Revision 1.33 by gbeauche, 2003-10-21T23:10:19Z vs.
Revision 1.34 by gbeauche, 2003-11-10T23:47:39Z