Mercurial > projects > dstress

changeset 1010:731f93c13ad6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
inline ASM review
author thomask
date Fri, 19 May 2006 17:44:18 +0000
parents 7d45295ced76
children 5b0ba71b22a9
files norun/a/asm_hlt_01.d norun/a/asm_invd_01.d run/a/asm_movsd_01_B.d run/a/asm_movsd_01_C.d run/a/asm_movupd_01_A.d run/a/asm_movupd_01_B.d run/a/asm_movupd_01_C.d run/a/asm_movups_01_A.d run/a/asm_movups_01_B.d run/a/asm_movups_01_C.d run/a/asm_movzx_01_A.d run/a/asm_movzx_01_B.d run/a/asm_movzx_01_C.d run/a/asm_movzx_02_A.d run/a/asm_movzx_02_B.d run/a/asm_movzx_02_C.d run/a/asm_mul_01_A.d run/a/asm_mul_01_B.d run/a/asm_mul_01_C.d run/a/asm_mul_02_A.d run/a/asm_mul_02_B.d run/a/asm_mul_02_C.d run/a/asm_mulpd_01_A.d run/a/asm_mulpd_01_B.d run/a/asm_mulps_01_A.d run/a/asm_mulps_01_B.d run/a/asm_mulsd_01_A.d run/a/asm_mulsd_01_B.d run/a/asm_mulss_01_A.d run/a/asm_mulss_01_B.d run/a/asm_neg_01_A.d run/a/asm_neg_01_B.d run/a/asm_neg_01_C.d run/a/asm_neg_02_A.d run/a/asm_neg_02_B.d run/a/asm_neg_02_C.d run/a/asm_nop_01.d run/a/asm_not_01_A.d run/a/asm_not_01_B.d run/a/asm_not_01_C.d run/a/asm_not_02_A.d run/a/asm_not_02_B.d run/a/asm_not_02_C.d run/a/asm_or_01_A.d run/a/asm_or_01_B.d run/a/asm_or_01_C.d run/a/asm_or_01_D.d run/a/asm_or_01_E.d run/a/asm_or_01_F.d run/a/asm_or_02_A.d run/a/asm_or_02_B.d run/a/asm_or_02_C.d run/a/asm_or_02_D.d run/a/asm_or_02_E.d run/a/asm_or_02_F.d run/a/asm_or_03_A.d run/a/asm_or_03_B.d run/a/asm_or_03_C.d run/a/asm_or_03_D.d run/a/asm_or_03_E.d run/a/asm_or_03_F.d run/a/asm_orpd_01_A.d
diffstat 62 files changed, 1562 insertions(+), 269 deletions(-) [+]
line wrap: on
line diff
--- a/norun/a/asm_hlt_01.d	Fri May 19 16:40:22 2006 +0000
+++ b/norun/a/asm_hlt_01.d	Fri May 19 17:44:18 2006 +0000
@@ -4,15 +4,21 @@
 
 module dstress.norun.a.asm_hlt_01;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		asm{
 			hlt;
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/norun/a/asm_invd_01.d	Fri May 19 16:40:22 2006 +0000
+++ b/norun/a/asm_invd_01.d	Fri May 19 17:44:18 2006 +0000
@@ -4,15 +4,21 @@
 
 module dstress.norun.a.asm_invd_01;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		asm{
 			invd;
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movsd_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,41 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movsd_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE2!()();
+		
+		static double[2] A = [1.0, 2.0];
+		double b = 3.0;
+		double[2] c;
+		
+		asm{
+			movupd XMM0, A;
+			movsd XMM0, b;
+			movupd c, XMM0;
+		}
+		
+		if(c[0] != b){
+			assert(0);
+		}
+		if(c[1] != 0.0){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movsd_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movsd_01_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE2!()();
+		
+		static double[2] A = [1.0, 2.0];
+		static double[2] B = [3.0, 4.0];
+		double[2] c;
+		
+		asm{
+			movupd XMM0, A;
+			movupd XMM1, B;
+			movsd XMM0, XMM1;
+			movupd c, XMM0;
+		}
+		
+		if(c[0] != B[0]){
+			assert(0);
+		}
+		if(c[1] != A[1]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_movupd_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movupd_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movupd_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
+
 		const double[2] A = [1.0, 4.0];
 		double[2] b;
 		
@@ -22,8 +32,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movupd_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movupd_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movupd_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE2!()();
+	
 		const double[2] A = [1.0, 4.0];
 		double[2] b;
 		
@@ -23,8 +33,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movupd_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movupd_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movupd_01_C;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE2!()();
+
 		const double[2] A = [1.0, 4.0];
 		double[2] b;
 		
@@ -22,8 +32,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movups_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movups_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,9 +4,19 @@
 
 module dstress.run.a.asm_movups_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		const float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
 		float[4] b;
 		
 		asm{
@@ -28,8 +38,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movups_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movups_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,9 +4,19 @@
 
 module dstress.run.a.asm_movups_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+		
+		const float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
 		float[4] b;
 		
 		asm{
@@ -29,8 +39,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movups_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movups_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,9 +4,19 @@
 
 module dstress.run.a.asm_movups_01_C;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+		
+		const float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
 		float[4] b;
 		
 		asm{
@@ -28,8 +38,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movzx_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movzx_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,14 +4,17 @@
 
 module dstress.run.a.asm_movzx_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint i = 0xFF_FF_FF_FFu;
 		ubyte b = 0xFF;
 		
-		assert(i==0xFF_FF_FF_FFu);
-		assert(b==0xFF);
-		
 		asm{
 			mov EAX, i;
 			mov AL, b;
@@ -44,8 +47,8 @@
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_movzx_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_movzx_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,14 +4,17 @@
 
 module dstress.run.a.asm_movzx_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint i = 0xFF_FF_FF_FFu;
 		ubyte b = 0xFF;
 		
-		assert(i==0xFF_FF_FF_FFu);
-		assert(b==0xFF);
-		
 		asm{
 			mov EAX, i;
 			mov AL, b;
@@ -44,8 +47,8 @@
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movzx_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,54 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movzx_01_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i = 0xFF_FF_FF_FFu;
+		ushort b = 0xFF_FF;
+		
+		asm{
+			mov EAX, i;
+			mov AX, b;
+			movzx EAX, AX;
+			mov i, EAX;
+		}
+	
+		if(i != 0x00_00_FF_FFu){
+			assert(0);
+		}
+		if(b != 0xFF_FF){
+			assert(0);
+		}
+		
+		i = 0xFF_FF_FF_FFu;
+		b = 0x12_34;
+		
+		asm{
+			mov EAX, i;
+			mov AX, b;
+			movzx EAX, AX;
+			mov i, EAX;
+		}
+		
+		if(i != 0x00_00_12_34u){
+			assert(0);
+		}
+		if(b != 0x12_34){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movzx_02_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,52 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movzx_02_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i = 0xFF_FF_FF_FFu;
+		ubyte b = 0xFF;
+		
+		asm{
+			mov EAX, i;
+			movzx AX, b;
+			mov i, EAX;
+		}
+	
+		if(i != 0xFF_FF_00_FFu){
+			assert(0);
+		}
+		if(b != 0xFF){
+			assert(0);
+		}
+		
+		i=0xFF_FF_FF_FFu;
+		b=0x12;
+		
+		asm{
+			mov EAX, i;
+			movzx AX, b;
+			mov i, EAX;
+		}
+		
+		if(i != 0xFF_FF_00_12u){
+			assert(0);
+		}
+		if(b != 0x12){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movzx_02_B.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,52 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movzx_02_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i = 0xFF_FF_FF_FFu;
+		ubyte b = 0xFF;
+		
+		asm{
+			mov EAX, i;
+			movzx EAX, b;
+			mov i, EAX;
+		}
+	
+		if(i != 0x00_00_00_FFu){
+			assert(0);
+		}
+		if(b != 0xFF){
+			assert(0);
+		}
+		
+		i = 0xFF_FF_FF_FFu;
+		b = 0x12;
+		
+		asm{
+			mov EAX, i;
+			movzx EAX, b;
+			mov i, EAX;
+		}
+		
+		if(i != 0x00_00_00_12u){
+			assert(0);
+		}
+		if(b != 0x12){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movzx_02_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,52 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movzx_02_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i = 0xFF_FF_FF_FFu;
+		ushort b = 0xFF_FF;
+		
+		asm{
+			mov EAX, i;
+			movzx EAX, b;
+			mov i, EAX;
+		}
+	
+		if(i != 0x00_00_FF_FFu){
+			assert(0);
+		}
+		if(b != 0xFF_FF){
+			assert(0);
+		}
+		
+		i = 0xFF_FF_FF_FFu;
+		b = 0x12_34;
+		
+		asm{
+			mov EAX, i;
+			movzx EAX, b;
+			mov i, EAX;
+		}
+		
+		if(i != 0x00_00_12_34u){
+			assert(0);
+		}
+		if(b != 0x12_34){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_mul_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mul_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_mul_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint i;
 		ubyte x = 0xFF;
 		
@@ -21,8 +27,8 @@
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_mul_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mul_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_mul_01_B;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		ushort a, b;
 		ushort x = short.max+2;
 		
@@ -18,12 +24,16 @@
 			mov b, AX;
 		}
 
-		assert(a==1u);
-		assert(b==2u);
+		if(a != 1){
+			assert(0);
+		}
+		if(b != 2){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_mul_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mul_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_mul_01_C;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint a, b;
 		uint x = int.max+2;
 		
@@ -18,12 +24,16 @@
 			mov b, EAX;
 		}
 
-		assert(a==1u);
-		assert(b==2u);
+		if(a != 1){
+			assert(0);
+		}
+		if(b != 2){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mul_02_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,35 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_mul_02_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i;
+		ubyte x = 0xFF;
+		
+		asm{
+			mov EAX, 0x23_43_56_78u;
+			mov AL, 0xEE;
+			mov BL, x;
+			mul BL;
+			mov i, EAX;
+		}
+
+		if(i != 0x23_43_ED_12){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mul_02_B.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,40 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_mul_02_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a, b;
+		ushort x = short.max+2;
+		
+		asm{
+			mov EAX, 0x12_34_56_78u;
+			mov EDX, 0x12_34_56_78u;
+			mov AX, 2;
+			mov BX, x;
+			mul BX;
+			mov a, DX;
+			mov b, AX;
+		}
+
+		if(a != 1){
+			assert(0);
+		}
+		if(b != 2){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mul_02_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,40 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_mul_02_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a, b;
+		uint x = int.max+2;
+		
+		asm{
+			mov EAX, 0x12_34_56_78u;
+			mov EDX, 0x12_34_56_78u;
+			mov EAX, 2;
+			mov EBX, x;
+			mul EBX;
+			mov a, EDX;
+			mov b, EAX;
+		}
+
+		if(a != 1){
+			assert(0);
+		}
+		if(b != 2){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_mulpd_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulpd_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,16 +4,26 @@
 
 module dstress.run.a.asm_mulpd_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
+
 		const double[2] A = [7.0, 4.0];
 		const double[2] B = [3.0, 2.0];
 		double[2] c;
 		
 		asm{
-			movdqu XMM0, A;
+			movupd XMM0, A;
 			mulpd XMM0, B;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 		
 		if(c[0] != 21.0){
@@ -24,8 +34,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_mulpd_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulpd_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_mulpd_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
+
 		const double[2] A = [7.0, 4.0];
 		const double[2] B = [3.0, 2.0];
 		double[2] c;
 		
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			mulpd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 		
 		if(c[0] != 21.0){
@@ -25,8 +35,8 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_mulps_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulps_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,16 +4,26 @@
 
 module dstress.run.a.asm_mulps_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+
 		const float[4] A = [7.0f, 4.0f, 1.0f, -2.0f];
 		const float[4] B = [3.0f, 2.0f, 0.0f, 5.0f];
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
+			movups XMM0, A;
 			mulps XMM0, B;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
 		if(c[0] != 21.0f){
@@ -29,10 +39,9 @@
 			assert(0);
 		}
 
-
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_mulps_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulps_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_mulps_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+
 		const float[4] A = [7.0f, 4.0f, 1.0f, -2.0f];
 		const float[4] B = [3.0f, 2.0f, 0.0f, 5.0f];
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			mulps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
 		if(c[0] != 21.0f){
@@ -30,10 +40,9 @@
 			assert(0);
 		}
 
-
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mulsd_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_mulsd_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
+
+		const double[2] A = [7.0, 4.0];
+		const double[2] B = [3.0, 2.0];
+		double[2] c;
+		
+		asm{
+			movupd XMM0, A;
+			movupd XMM1, B;
+			mulsd XMM0, XMM1;
+			movupd c, XMM0;
+		}
+		
+		if(c[0] != 7.0){
+			assert(0);
+		}
+		if(c[1] != 8.0){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mulsd_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,41 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_mulsd_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
+
+		const double[2] A = [7.0, 4.0];
+		const double B = 2.0;
+		double[2] c;
+		
+		asm{
+			movupd XMM0, A;
+			mulsd XMM0, B;
+			movupd c, XMM0;
+		}
+		
+		if(c[0] != 7.0){
+			assert(0);
+		}
+		if(c[1] != 8.0){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_mulss_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulss_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,36 +4,45 @@
 
 module dstress.run.a.asm_mulss_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+
 		const float[4] A = [7.0f, 4.0f, 1.0f, -2.0f];
 		const float[4] B = [3.0f, 2.0f, 0.0f, 5.0f];
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			mulss XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
-		if(c[0] != 21.0f){
+		if(c[0] != 7.0f){
 			assert(0);
 		}
-		if(c[1] != A[1]){
+		if(c[1] != 4.0f){
 			assert(0);
 		}
-		if(c[2] != A[2]){
+		if(c[2] != 1.0f){
 			assert(0);
 		}
-		if(c[3] != A[3]){
+		if(c[3] != -10.0f){
 			assert(0);
 		}
 
-
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_mulss_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_mulss_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,35 +4,44 @@
 
 module dstress.run.a.asm_mulss_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+
 		const float[4] A = [7.0f, 4.0f, 1.0f, -2.0f];
-		const float B = 3.0f;
+		const float B = 5.0f;
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
+			movups XMM0, A;
 			mulss XMM0, B;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
-		if(c[0] != 21.0f){
+		if(c[0] != 7.0f){
 			assert(0);
 		}
-		if(c[1] != A[1]){
+		if(c[1] != 4.0f){
 			assert(0);
 		}
-		if(c[2] != A[2]){
+		if(c[2] != 1.0f){
 			assert(0);
 		}
-		if(c[3] != A[3]){
+		if(c[3] != -10.0f){
 			assert(0);
 		}
 
-
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_neg_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_neg_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_neg_01_A;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		byte y = 2;
 				
 		asm{
 			neg y;
 		}
 
-		assert(y == -2);
+		if(y != -2){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_neg_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_neg_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_neg_01_B;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		short y = -1234;
 				
 		asm{
 			neg y;
 		}
 
-		assert(y == 1234);
+		if(y != 1234){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_neg_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_neg_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_neg_01_C;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		int y = 0x12_34_56_78;
 				
 		asm{
 			neg y;
 		}
 
-		assert(y == - 0x12_34_56_78);
+		if(y != - 0x12_34_56_78){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_neg_02_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_neg_02_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint y = 0x78_56_43_21;
+				
+		asm{
+			mov EAX, y;
+			neg AL;
+			mov y, EAX;
+		}
+
+		if(y != 0x78_56_43_DF){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_neg_02_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_neg_02_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,20 +4,29 @@
 
 module dstress.run.a.asm_neg_02_B;
 
-int main(){
-	version(D_InlineAsm){
-		short y = -1234;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint y = 0x78_56_43_21;
 				
 		asm{
-			lock;
-			neg y;
+			mov EAX, y;
+			neg AX;
+			mov y, EAX;
 		}
 
-		assert(y == 1234);
+		if(y != 0x78_56_BC_DF){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_neg_02_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_neg_02_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,20 +4,29 @@
 
 module dstress.run.a.asm_neg_02_C;
 
-int main(){
-	version(D_InlineAsm){
-		int y = 0x12_34_56_78;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint y = 0x78_56_43_21;
 				
 		asm{
-			lock;
-			neg y;
+			mov EAX, y;
+			neg EAX;
+			mov y, EAX;
 		}
 
-		assert(y == - 0x12_34_56_78);
+		if(y != 0x87_A9_BC_DF){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_nop_01.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_nop_01.d	Fri May 19 17:44:18 2006 +0000
@@ -4,16 +4,21 @@
 
 module dstress.run.a.asm_nop_01;
 
-int main(){
-	version(D_InlineAsm){
-	
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		asm{
 			nop;
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_not_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_not_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_not_01_A;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		ubyte a = 0b0110_1110;
 		
 		asm{
 			not a;
 		}
 		
-		assert(a == 0b1001_0001);
+		if(a != 0b1001_0001){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_not_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_not_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_not_01_B;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		ushort a = 0b0110_1110_0000_1111;
 		
 		asm{
 			not a;
 		}
 		
-		assert(a == 0b1001_0001_1111_0000);
+		if(a != 0b1001_0001_1111_0000){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_not_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_not_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,19 +4,27 @@
 
 module dstress.run.a.asm_not_01_C;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
 		
 		asm{
 			not a;
 		}
 		
-		assert(a == 0b1001_0001__1111_0000_0011_1100_1100_0000);
+		if(a != 0b1001_0001__1111_0000_0011_1100_1100_0000){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_not_02_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_not_02_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_not_02_A;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint i;
 		
 		asm{
@@ -20,8 +26,8 @@
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_not_02_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_not_02_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_not_02_B;
 
-int main(){
-	version(D_InlineAsm_X86){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint i;
 		
 		asm{
@@ -20,8 +26,8 @@
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_not_02_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_not_02_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i;
+		
+		asm{
+			mov EAX,  0b0110_1110__0000_1111__1100_0011__0011_1111;
+			not EAX;
+			mov i, EAX;
+		}
+		
+		if(i != 0b1001_0001__1111_0000__0011_1100__1100_0000){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_or_01_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_or_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_or_01_A;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
 		uint b = 0b1110_1111__1111_1111__1111_1110__0111_1111;
 		
@@ -14,11 +20,13 @@
 			or b, EAX;
 		}
 		
-		assert(b == 0b1110_1111__1111_1111__1111_1111__0111_1111);
+		if(b != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_or_01_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_or_01_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,21 +4,31 @@
 
 module dstress.run.a.asm_or_01_B;
 
-int main(){
-	version(D_InlineAsm){
-		ushort a = 0b0110_1110__0000_1111;
-		ushort b = 0b1110_1111__1110_0111;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		uint b = 0b1110_1111__1111_1111__1111_1110__0111_1111;
 		
 		asm{
-			mov AX, a;
-			or b, AX;
+			mov EAX, a;
+			mov EBX, b;
+			or EBX, EAX;
+			mov b, EBX;
 		}
 		
-		assert(b == 0b1110_1111__1110_1111);
+		if(b != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_or_01_C.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_or_01_C.d	Fri May 19 17:44:18 2006 +0000
@@ -4,21 +4,30 @@
 
 module dstress.run.a.asm_or_01_C;
 
-int main(){
-	version(D_InlineAsm){
-		ubyte a = 0b0110_1110;
-		ubyte b = 0b1110_1111;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		uint b = 0b1110_1111__1111_1111__1111_1110__0111_1111;
 		
 		asm{
-			mov AL, a;
-			or b, AL;
+			mov EBX, b;
+			or EBX, a;
+			mov b, EBX;
 		}
 		
-		assert(b == 0b1110_1111);
+		if(b != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
-}
\ No newline at end of file
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_01_D.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_01_D;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint b = 0b1110_1111__1111_1111__1111_1110__0111_1111;
+		
+		asm{
+			mov EBX, b;
+			or EBX, 0b0110_1110__0000_1111__1100_0011__0011_1111;
+			mov b, EBX;
+		}
+		
+		if(b != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_01_E.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_01_E;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint b = 0b1110_1111__1111_1111__1111_1110__0111_1111;
+		
+		asm{
+			or b, 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		}
+		
+		if(b != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_01_F.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_01_F;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b1110_1111__1111_1111__1111_1110__0111_1111;
+		
+		asm{
+			mov EAX, a;
+			or EAX, 0b0110_1110__0000_1111__1100_0011__0011_1111;
+			mov a, EAX;
+		}
+		
+		if(a != 0b1110_1111__1111_1111__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- a/run/a/asm_or_02_A.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_or_02_A.d	Fri May 19 17:44:18 2006 +0000
@@ -4,24 +4,29 @@
 
 module dstress.run.a.asm_or_02_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		uint a;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		ushort b = 0b1111_1110__0111_1111;
 		
 		asm{
-			mov EAX, 0x45_FD_BC_67;
-			mov AL, 0b0100_0001;
-			or AL, 0b0001_1000;
-			mov a, EAX;
+			mov EAX, a;
+			or b, AX;
 		}
 		
-		if(a != (0x45_FD_BC_00 | 0b0101_1001)){
+		if(b != 0b1111_1111__0111_1111){
 			assert(0);
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- a/run/a/asm_or_02_B.d	Fri May 19 16:40:22 2006 +0000
+++ b/run/a/asm_or_02_B.d	Fri May 19 17:44:18 2006 +0000
@@ -4,24 +4,31 @@
 
 module dstress.run.a.asm_or_02_B;
 
-int main(){
-	version(D_InlineAsm_X86){
-		uint a;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b1110_1111__1111_1111__1111_1110__0111_1111;
+		uint b = 0b0110_1110__0000_1111__1100_0011__0011_1111;
 		
 		asm{
-			mov EAX, 0x45_FD_BC_67;
-			mov AX, 0b0000_1111_0100_0001;
-			or AX,  0b1010_0001_0001_1000;
-			mov a, EAX;
+			mov EAX, a;
+			mov EBX, b;
+			or BX, AX;
+			mov b, EBX;
 		}
 		
-		if(a != (0x45_FD_00_00 | 0b1010_1111_0101_1001)){
+		if(b != 0b0110_1110__0000_1111__1111_1111__0111_1111){
 			assert(0);
 		}
 		
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_02_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,33 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_02_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a = 0b1111_1110__0111_1111;
+		uint b = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		
+		asm{
+			mov EBX, b;
+			or BX, a;
+			mov b, EBX;
+		}
+		
+		if(b != 0b0110_1110__0000_1111__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_02_D.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_02_D;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint b = 0b1110_1111__1111_0000__1111_1110__0111_1111;
+		
+		asm{
+			mov EBX, b;
+			or BX, 0b1100_0011__0011_1111;
+			mov b, EBX;
+		}
+		
+		if(b != 0b1110_1111__1111_0000__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_02_E.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_02_E;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort b = 0b1111_1110__0111_1111;
+		
+		asm{
+			or b, 0b1100_0011__0011_1111;
+		}
+		
+		if(b != 0b1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_02_F.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_02_F;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b1110_1111__1111_0000__1111_1110__0111_1111;
+		
+		asm{
+			mov EAX, a;
+			or AX, 0b1100_0011__0011_1111;
+			mov a, EAX;
+		}
+		
+		if(a != 0b1110_1111__1111_0000__1111_1111__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		ubyte b = 0b0111_0111;
+		
+		asm{
+			mov EAX, a;
+			or b, AL;
+		}
+		
+		if(b != 0b0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_B.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,34 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b1110_1111__1111_1111__1111_1110__0111_1111;
+		uint b = 0b0110_1110__0000_1111__1100_0011__0011_0111;
+		
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			or BL, AL;
+			mov b, EBX;
+		}
+		
+		if(b != 0b0110_1110__0000_1111__1100_0011__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_C.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,33 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte a = 0b0111_0111;
+		uint b = 0b0110_1110__0000_1111__1100_0011__0011_1111;
+		
+		asm{
+			mov EBX, b;
+			or BL, a;
+			mov b, EBX;
+		}
+		
+		if(b != 0b0110_1110__0000_1111__1100_0011__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_D.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_D;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint b = 0b1110_1111__1111_0000__1111_1110__0111_0111;
+		
+		asm{
+			mov EBX, b;
+			or BL, 0b0011_1111;
+			mov b, EBX;
+		}
+		
+		if(b != 0b1110_1111__1111_0000__1111_1110__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_E.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_E;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte b = 0b0111_0111;
+		
+		asm{
+			or b, 0b0011_1111;
+		}
+		
+		if(b != 0b0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_or_03_F.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_or_03_F;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0b1110_1111__1111_0000__1111_1110__0111_0111;
+		
+		asm{
+			mov EAX, a;
+			or AL, 0b0011_1111;
+			mov a, EAX;
+		}
+		
+		if(a != 0b1110_1111__1111_0000__1111_1110__0111_1111){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_orpd_01_A.d	Fri May 19 17:44:18 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_orpd_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE2!()();
+
+		static double[2] A = [4.0, 8.0];
+		static double[2] B = [3.0, 4.0];
+		double[2] c;
+				
+		asm{
+			movupd XMM0, A;
+			movupd XMM1, B;
+			orpd XMM0, XMM1;
+			movupd c, XMM0;
+		}
+
+		if(c[0] != 6.0){
+			assert(0);
+		}
+		if(c[1] != 16.0){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}