# HG changeset patch
# User thomask
# Date 1147968426 0
# Node ID a7310ceac84472b297e070a66c73760efcedc8d2
# Parent  eb5364abce0c7379673ae1f5618da92cafe72644
inline ASM review

diff -r eb5364abce0c -r a7310ceac844 addon/cpuinfo.d
--- a/addon/cpuinfo.d	Wed May 17 06:06:45 2006 +0000
+++ b/addon/cpuinfo.d	Thu May 18 16:07:06 2006 +0000
@@ -14,7 +14,7 @@
 		const bool haveX86InlineAsm = true;
 		version = haveX86InlineAsm;
 	}else{
-		pragma(msg, "no Inline ASM support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		const bool haveX86InlineAsm = false;
 	}
 }else version(D_InlineAsm_X86){
@@ -24,7 +24,7 @@
 	const bool haveX86InlineAsm = true;
 	version = haveX86InlineAsm;
 }else{
-	pragma(msg, "no Inline ASM support");
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 	const bool haveX86InlineAsm = false;
 }
 
@@ -39,6 +39,8 @@
 				cpuid;
 				mov a, EDX;
 			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		}
 
 		if(!((a >> 15) & 1)){
@@ -46,7 +48,7 @@
 		}
 	}
 }
-	
+
 void haveCX8(){
 	uint a = 0;
 
@@ -66,67 +68,80 @@
 template haveFPU(){
 	void haveFPU(){
 		uint a = 0;
-		
+
 		version(haveX86InlineAsm){
 			asm{
 				mov EAX, 1;
 				cpuid;
 				mov a, EDX;
 			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		}
-		
+
 		if(!(a & 1)){
 			throw new Exception("DSTRESS{XFAIL}: no X86 FPU present");
 		}
 	}
 }
 
-void haveMMX(){
-	uint a = 0;
-		
-	version(haveX86InlineAsm){
-		asm{
-			mov EAX, 1;
-			cpuid;
-			mov a, EDX;
+template haveMMX(){
+	void haveMMX(){
+		uint a = 0;
+
+		version(haveX86InlineAsm){
+			asm{
+				mov EAX, 1;
+				cpuid;
+				mov a, EDX;
+			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		}
-	}
-		
-	if(!((a >> 23) & 1)){
-		throw new Exception("no X86 MMX support present");
+
+		if(!((a >> 23) & 1)){
+			throw new Exception("DSTRESS{XFAIL}: no MMX support present");
+		}
 	}
 }
 
-	
-void haveSSE(){
-	uint a = 0;
-			
-	version(haveX86InlineAsm){
-		asm{
-			mov EAX, 1;
-			cpuid;
-			mov a, EDX;
+template haveSSE(){
+	void haveSSE(){
+		uint a = 0;
+
+		version(haveX86InlineAsm){
+			asm{
+				mov EAX, 1;
+				cpuid;
+				mov a, EDX;
+			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		}
+
+		if(!((a >> 25) & 1)){
+			throw new Exception("DSTRESS{XFAIL}: no SSE support present");
 		}
 	}
-
-	if(!((a >> 25) & 1)){
-		throw new Exception("no X86 SSE support present");
-	}	
 }
 
-void haveSSE2(){
-	uint a = 0;
-		
-	version(haveX86InlineAsm){
-		asm{
-			mov EAX, 1;
-			cpuid;
-			mov a, EDX;
+template haveSSE2(){
+	void haveSSE2(){
+		uint a = 0;
+
+		version(haveX86InlineAsm){
+			asm{
+				mov EAX, 1;
+				cpuid;
+				mov a, EDX;
+			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		}
-	}
 
-	if(!((a >> 26) & 1)){
-		throw new Exception("no X86 SSE2 support present");
+		if(!((a >> 26) & 1)){
+			throw new Exception("DSTRESS{XFAIL}: no SSE2 support present");
+		}
 	}
 }
 
@@ -134,15 +149,17 @@
 	void haveSSE3(){
 		uint a = 1;
 		uint b = 0;
-			
+
 		version(haveX86InlineAsm){
 			asm{
 				mov EAX, a;
 				cpuid;
 				mov b, ECX;
 			}
+		}else{
+			pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		}
-	
+
 		if(!(a & 1)){
 			throw new Exception("DSTRESS{XFAIL}: no SSE3 support present");
 		}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lahf_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_lahf_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,37 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_lahf_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i = 0x12_34_56_01;
+
+		asm{
+			mov EAX, i;
+			cmp AL, 2;
+			lahf;
+			mov i, EAX;
+		}
+
+		if((i & 0xFF_FF_00_FF) != 0x12_34_00_01){
+			assert(0);
+		}
+
+		ubyte b = (i & 0x00_00_FF_00) >> 8;
+
+		if(b != 151){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lar_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_lar_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,25 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_lar_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		asm{
+			mov AX, 0x0;
+			lar BX, AX;
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lddqu_01.d
--- a/run/a/asm_lddqu_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_lddqu_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,39 +4,40 @@
 
 module dstress.run.a.asm_lddqu_01;
 
-align(1) struct X{
-	ubyte a;
-	ulong b;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
 }
 
-align(16) struct Y{
-	ulong c;
-}
-		
-int main(){
-	version(D_InlineAsm){	
-		X* x = new X;
+version(runTest){
+	import addon.cpuinfo;
 	
-		assert(cast(size_t)&(x.b) % 2 == 1);
-		
-		x.b = 0x0123_4567_89AB_CDEF_LU;
-		
-		Y* y = new Y;
-		
-		assert(cast(size_t)&(y.c) % 16 == 0);
-		
+	int main(){
+		haveSSE3!()();
+
+		const ubyte[16] A = [1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+		ubyte[16] b;
+
 		asm{
-			mov EAX, x;
-			lddqu XMM0, X.b[EAX];
-			mov EAX, y;
-			movdqa Y.c[EAX], XMM0;
+			lddqu XMM0, A;
+			movdqu b, XMM0;
+		}
+
+		if(A.length != b.length){
+			assert(0);
+		}
+
+		for(size_t i = 0; i < A.lenght; i++){
+			if(A[i] != b[i]){
+				assert(0);
+			}
 		}
 		
-		assert(y.c==0x0123_4567_89AB_CDEF_LU);
-		
 		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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_ldmxcsr_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_ldmxcsr_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_ldmxcsr_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveMMX!()();
+
+		uint state = 0x0000_1F80;
+
+		asm{
+			ldmxcsr state;
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lea_01_A.d
--- a/run/a/asm_lea_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_lea_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_lea_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 a;
 		uint b;
 		
@@ -19,8 +25,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lea_01_B.d
--- a/run/a/asm_lea_01_B.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_lea_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_lea_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(){
 		ushort i;
 		
 		asm{
@@ -18,8 +24,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_leave_01.d
--- a/run/a/asm_leave_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_leave_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_leave_01;
 
-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 = 1;
 		
 		asm{
@@ -16,11 +22,13 @@
 			mov a, EAX;
 		}
 		
-		assert(a == 2);
+		if(a != 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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lfence_01.d
--- a/run/a/asm_lfence_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_lfence_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,16 +4,21 @@
 
 module dstress.run.a.asm_lfence_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{
 			lfence;
 		}
 		
 		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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_lock_01.d
--- a/run/a/asm_lock_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_lock_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_lock_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(){
 		uint i = 0;
 		asm{
 			lock;
@@ -16,8 +22,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_loop_01.d
--- a/run/a/asm_loop_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_loop_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_loop_01;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
 		int a;
 		
 		asm{
@@ -16,11 +22,13 @@
 			mov a, EAX;
 		}
 		
-		assert(a == 10);
+		if(a != 10){
+			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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_loope_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_loope_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,34 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_loope_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		int a;
+		
+		asm{
+			mov EAX, -1;
+			mov ECX, 10;
+		start:	inc EAX;
+			loope start;
+			mov a, EAX;
+		}
+		
+		if(a != 1){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_loopne_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_loopne_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,34 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_loopne_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		int a;
+		
+		asm{
+			mov EAX, -5;
+			mov ECX, 10;
+		start:	inc EAX;
+			loopne start;
+			mov a, EAX;
+		}
+		
+		if(a != 0){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_maxpd_01_A.d
--- a/run/a/asm_maxpd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_maxpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxpd_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!()();
+
 		static double[2] A = [2.0, 3.0];
 		static double[2] B = [1.0, 4.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			maxpd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		if(c[0] != 2.0){
@@ -26,8 +36,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_maxps_01_A.d
--- a/run/a/asm_maxps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_maxps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxps_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!()();
+
 		static float[4] A = [2.0f, 3.0f, 16.0f, -1.0f];
 		static float[4] B = [1.0f, 4.0f, -17.0f, 1.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			maxps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		if(c[0] != 2.0f){
@@ -33,8 +43,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_maxsd_01_A.d
--- a/run/a/asm_maxsd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_maxsd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxsd_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!()();
+
 		static double[2] A = [1.0, 3.0];
 		static double[2] B = [2.0, 4.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			maxsd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		if(c[0] != 2.0){
@@ -26,8 +36,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_maxss_01_A.d
--- a/run/a/asm_maxss_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_maxss_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxss_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!()();
+
 		static float[4] A = [1.0f, 3.0f, 16.0f, -1.0f];
 		static float[4] B = [2.0f, 4.0f, -17.0f, 1.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			maxss XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		if(c[0] != 2.0f){
@@ -33,8 +43,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mfence_01.d
--- a/run/a/asm_mfence_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_mfence_01.d	Thu May 18 16:07:06 2006 +0000
@@ -2,18 +2,23 @@
 // $Date$
 // $Author$
 
-module dstress.run.a.asm_lfence_01;
+module dstress.run.a.asm_mfence_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{
 			mfence;
 		}
 		
 		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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minpd_01_A.d
--- a/run/a/asm_minpd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_minpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_minpd_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		static double[2] A = [2.0, 4.0];
-		static double[2] B = [1.0, 3.0];
+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 = [2.0, 3.0];
+		static double[2] B = [1.0, 4.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			minpd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		if(c[0] != 1.0){
@@ -26,8 +36,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minps_01_A.d
--- a/run/a/asm_minps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_minps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxps_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!()();
+
 		static float[4] A = [2.0f, 3.0f, 17.0f, -1.0f];
 		static float[4] B = [1.0f, 4.0f, 16.0f, 1.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			minps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		if(c[0] != 1.0f){
@@ -33,8 +43,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minsd_01_A.d
--- a/run/a/asm_minsd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_minsd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_minsd_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!()();
+
 		static double[2] A = [2.0, 4.0];
 		static double[2] B = [1.0, 3.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			minsd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		if(c[0] != 1.0){
@@ -26,8 +36,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minsd_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_minsd_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,41 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_minsd_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 = [3.0, 4.0];
+		double b = 2.0;
+		double[2] c;
+
+		asm{
+			movupd XMM0, A;
+			minsd XMM0, b;
+			movupd c, XMM0;
+		}
+
+		if(c[0] != 2.0){
+			assert(0);
+	 	}
+		if(c[1] != 4.0){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minss_01_A.d
--- a/run/a/asm_minss_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_minss_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,17 +4,27 @@
 
 module dstress.run.a.asm_maxss_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!()();
+
 		static float[4] A = [2.0f, 3.0f, 17.0f, -1.0f];
 		static float[4] B = [1.0f, 4.0f, 16.0f, 1.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			minss XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		if(c[0] != 1.0f){
@@ -33,8 +43,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_minss_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_minss_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,49 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_maxss_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [2.0f, 3.0f, 17.0f, -1.0f];
+		float b = 1.0f;
+		float[4] c;
+
+		asm{
+			movups XMM0, A;
+			minss XMM0, b;
+			movups c, XMM0;
+		}
+
+		if(c[0] != 1.0f){
+			assert(0);
+		}
+
+		if(c[1] != 3.0f){
+			assert(0);
+		}
+		
+		if(c[2] != 17.0f){
+			assert(0);
+		}
+
+		if(c[3] != -1.0f){
+			assert(0);
+		}
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01.d
--- a/run/a/asm_mov_01.d	Wed May 17 06:06:45 2006 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
- // $HeadURL$
- // $Date$
- // $Author$
- 
-module dstress.run.a.asm_mov_01;
-
-int test(){
-	asm{
-		naked;
-		mov EAX, 10;
-    		ret;
-	}
-}
-
-int main(){
-	assert(test()==10);
-        return 0;
-}
\ No newline at end of file
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,37 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte a = 0xFE;
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov AL, a;
+			mov i, EAX;
+		}
+
+		if(a != 0xFE){
+			assert(0);
+		}
+
+		if(i != 0x12_34_56_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,38 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte a = 0xFE;
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov BL, a;
+			mov AL, BL;
+			mov i, EAX;
+		}
+
+		if(a != 0xFE){
+			assert(0);
+		}
+
+		if(i != 0x12_34_56_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_01_C.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,31 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_01_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte a = 0xFE;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov a, AL;
+		}
+
+		if(a != 0x78){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01_D.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_01_D.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_01_D;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov AL, 0xFE;
+			mov i, EAX;
+		}
+
+		if(i != 0x12_34_56_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_01_E.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_01_E.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,30 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_01_E;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ubyte a = 0xFE;
+
+		asm{
+			mov a, 0x12;
+		}
+
+		if(a != 0x12){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_02_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,37 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_02_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a = 0x33_FE;
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov AX, a;
+			mov i, EAX;
+		}
+
+		if(a != 0x33_FE){
+			assert(0);
+		}
+
+		if(i != 0x12_34_33_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_02_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,38 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_02_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a = 0x33_FE;
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov BX, a;
+			mov AX, BX;
+			mov i, EAX;
+		}
+
+		if(a != 0x33_FE){
+			assert(0);
+		}
+
+		if(i != 0x12_34_33_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_02_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_02_C.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,31 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_02_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a = 0xFE;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov a, AX;
+		}
+
+		if(a != 0x56_78){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_02_D.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_02_D.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_02_D;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint i;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov AX, 0x33_FE;
+			mov i, EAX;
+		}
+
+		if(i != 0x12_34_33_FE){
+			assert(0);
+		}
+    		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_02_E.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_02_E.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,30 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_02_E;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		ushort a = 0xFE_33;
+
+		asm{
+			mov a, 0x12_45;
+		}
+
+		if(a != 0x12_45){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_03_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_03_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,36 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_03_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a = 0x12_34_56_78;
+		uint b;
+
+		asm{
+			mov EAX, a;
+			mov b, EAX;
+		}
+
+		if(a != 0x12_34_56_78){
+			assert(0);
+		}
+
+		if(b != 0x12_34_56_78){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_03_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_03_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,31 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_03_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a;
+
+		asm{
+			mov EAX, 0x12_34_56_78;
+			mov a, EAX;
+		}
+
+		if(a != 0x12_34_56_78){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_mov_03_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_mov_03_C.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,30 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_mov_03_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		uint a;
+
+		asm{
+			mov a, 0x12_34_56_78;
+		}
+
+		if(a != 0x12_34_56_78){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movapd_01_A.d
--- a/run/a/asm_movapd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movapd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movapd_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!()();
+
 		static double[2] A = [2.0, 3.0];
 		double[2] b;
 
@@ -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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movaps_01_A.d
--- a/run/a/asm_movaps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movaps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movaps_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!()();
+
 		static float[4] A = [2.0f, 3.0f, 0.0f, 0.5f];
 		float[4] b;
 
@@ -31,8 +41,8 @@
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movd_01.d
--- a/run/a/asm_movd_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movd_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,9 +4,18 @@
 
 module dstress.run.a.asm_movd_01;
 
-int main(){
-	version(D_InlineAsm){
-		
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveMMX!()();
+
 		uint a = 0x1234_ABCD;
 		int b = 2;
 		
@@ -15,11 +24,13 @@
 			movd b, MM0;
 		}
 		
-		assert(a==b);
+		if(a != b){
+			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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movddup_01_A.d
--- a/run/a/asm_movddup_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movddup_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,16 +4,26 @@
 
 module dstress.run.a.asm_movddup_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(){
+		haveSSE3!()();
+
 		static double[2] A = [2.0, 3.0];
 		double[2] b;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, A;
+			movupd XMM0, A;
+			movupd XMM1, A;
 			movddup XMM1, XMM0;
-			movdqu b, XMM1;
+			movupd b, XMM1;
 		}
 
 		if(A[0] != b[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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movddup_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movddup_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movddup_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE3!()();
+
+		static double[2] A = [2.0, 3.0];
+		double[2] b;
+		double c = 1.0;
+
+		asm{
+			movupd XMM0, A;
+			movddup XMM0, c;
+			movupd b, XMM0;
+		}
+
+		if(b[0] != 1.0){
+			assert(0);
+		}
+
+		if(b[1] != 1.0){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movdq2q_01.d
--- a/run/a/asm_movdq2q_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movdq2q_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,22 +4,32 @@
 
 module dstress.run.a.asm_movdq2q_01;
 
-int main(){
-	version(D_InlineAsm){
-		double a = -2.5;
-		double b = 1.1;
+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;
 		
 		asm{
-			movq XMM0, a;
+			movupd XMM0, A;
 			movdq2q MM0, XMM0;
 			movq b, XMM0;
 		}
 		
-		if(a==b){
+		if(b != A[1]){
 			return 0;
 		}
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhlpd_01_A.d
--- a/run/a/asm_movhlpd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-// $HeadURL$
-// $Date$
-// $Author$
-
-module dstress.run.a.asm_movhlpd_01_A;
-
-int main(){
-	version(D_InlineAsm_X86){
-		static double[2] A = [1.0, 2.0];
-		static double B = 4.0;
-		double[2] b;
-
-		asm{
-			movdqu XMM0, A;
-			movhpd XMM0, B;
-			movdqu b, XMM0;
-		}
-
-		if(b[0] != A[0]){
-			assert(0);
-		}
-
-		if(b[1] != B){
-			assert(0);
-		}
-		
-		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
-	}
-}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhlps_01_A.d
--- a/run/a/asm_movhlps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movhlps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -8,17 +8,27 @@
 
 module dstress.run.a.asm_movhlps_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!()();
+
 		static float[4] A = [3.0f, 4.0f, 5.0f, 6.0f];
 		static float[4] B = [10.0f, 20.0f, 30.0f, 40.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			movlhps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		if(c[0] != A[0]){
@@ -38,8 +48,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhpd_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movhpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movhpd_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 = [1.0, 2.0];
+		double B = 4.0;
+		double[2] b;
+
+		asm{
+			movupd XMM0, A;
+			movhpd XMM0, B;
+			movupd b, XMM0;
+		}
+
+		if(b[0] != A[0]){
+			assert(0);
+		}
+
+		if(b[1] != B){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhpd_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movhpd_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,36 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movhpd_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;
+
+		asm{
+			movupd XMM0, A;
+			movhpd b, XMM0;
+		}
+
+		if(b != A[1]){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhps_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movhps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,47 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movhps_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
+		static float[2] B = [5.0f, 6.0f];
+		float[4] c;
+
+		asm{
+			movups XMM0, A;
+			movhps XMM0, B;
+			movups c, XMM0;
+		}
+
+		if(c[0] != A[0]){
+			assert(0);
+		}
+		if(c[1] != A[1]){
+			assert(0);
+		}
+		if(c[2] != B[0]){
+			assert(0);
+		}
+		if(c[3] != B[1]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movhps_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movhps_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,39 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movhps_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
+		float[2] b;
+
+		asm{
+			movups XMM0, A;
+			movhps b, XMM0;
+		}
+
+		if(b[0] != A[2]){
+			assert(0);
+		}
+		if(b[1] != A[3]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movlhps_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movlhps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,51 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlhps_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [3.0f, 4.0f, 5.0f, 6.0f];
+		static float[4] B = [10.0f, 20.0f, 30.0f, 40.0f];
+		float[4] c;
+
+		asm{
+			movups XMM0, A;
+			movups XMM1, B;
+			movlhps XMM0, XMM1;
+			movups c, XMM0;
+		}
+
+		if(c[0] != B[2]){
+			assert(0);
+		}
+
+		if(c[1] != B[3]){
+			assert(0);
+		}
+		
+		if(c[2] != A[2]){
+			assert(0);
+		}
+
+		if(c[3] != A[3]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movlpd_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movlpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,42 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlpd_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 = [3.0, 4.0];
+		double b = 5.0;
+		double[2] c;
+
+		asm{
+			movups XMM0, A;
+			movlpd XMM0, b;
+			movups c, XMM0;
+		}
+
+		if(c[0] != b){
+			assert(0);
+		}
+
+		if(c[1] != A[1]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movlpd_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movlpd_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,36 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlpd_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 = [3.0, 4.0];
+		double b = 5.0;
+
+		asm{
+			movups XMM0, A;
+			movlpd b, XMM0;
+		}
+
+		if(b != A[0]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movlps_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movlps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,47 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlps_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
+		static float[2] B = [5.0f, 6.0f];
+		
+		float[4] c;
+
+		asm{
+			movups XMM0, A;
+			movlps XMM0, B;
+			movups c, XMM0;
+		}
+
+		if(c[0] != B[0]){
+			assert(0);
+		}
+		if(c[1] != B[1]){
+			assert(0);
+		}
+		if(c[2] != A[2]){
+			assert(0);
+		}
+		if(c[3] != A[3]){
+			assert(0);
+		}
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movlps_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movlps_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,39 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlps_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
+		float[2] b;
+
+		asm{
+			movups XMM0, A;
+			movlps b, XMM0;
+		}
+
+		if(b[0] != A[0]){
+			assert(0);
+		}
+		if(b[1] != A[1]){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movmskpd_01_A.d
--- a/run/a/asm_movmskpd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movmskpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,25 +4,35 @@
 
 module dstress.run.a.asm_movmskpd_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, -1.0];
 		uint b;
 		
 		asm{
-			movdqu XMM0, a;
-			mov EAX, 0xFFFF_FFFF;
+			movupd XMM0, a;
+			mov EAX, 0x1234_5678;
 			movmskpd EAX, XMM0;
 			mov b, EAX;
 		}
 		
-		if(b != 0xFFFF_FF02){
+		if(b != 0x0000_0002){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movmskps_01_A.d
--- a/run/a/asm_movmskps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movmskps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,25 +4,35 @@
 
 module dstress.run.a.asm_movmskps_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] a = [1.0, -1.0, +0.0, -0.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, -1.0f, -float.infinity, -0.0f];
 		uint b;
 		
 		asm{
-			movdqu XMM0, a;
-			mov EAX, 0xFFFF_FFFF;
+			movdqu XMM0, A;
+			mov EAX, 0x1234_5678;
 			movmskps EAX, XMM0;
 			mov b, EAX;
 		}
 		
-		if(b != 0xFFFF_FF06){
+		if(b != 0x0000_0004){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movnti_01.d
--- a/run/a/asm_movnti_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movnti_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,9 +4,14 @@
 
 module dstress.run.a.asm_movnti_01;
 
-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 = 0x1234_ABCD;
 		uint b = 2;
 		
@@ -15,12 +20,16 @@
 			movnti b, EAX;
 		}
 		
-		assert(a==b);
-		assert(b==0x1234_ABCD);
+		if(a != 0x1234_ABCD){
+			assert(0);
+		}
+		if(b != 0x1234_ABCD){
+			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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movntpd_01_A.d
--- a/run/a/asm_movntpd_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movntpd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,13 +4,23 @@
 
 module dstress.run.a.asm_movntpd_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, -1.0];
 		double[2] b;
 		
 		asm{
-			movdqu XMM0, a;
+			movupd XMM0, a;
 			movntpd b, XMM0;
 		}
 		
@@ -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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movntps_01_A.d
--- a/run/a/asm_movntps_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movntps_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,13 +4,23 @@
 
 module dstress.run.a.asm_movntps_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] a = [1.0, -1.0, 0.0, 0.1];
+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, -1.0f, 0.0f, 0.1f];
 		float[4] b;
 		
 		asm{
-			movdqu XMM0, a;
+			movups XMM0, a;
 			movntps b, XMM0;
 		}
 		
@@ -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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movntq_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movntq_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,39 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movlps_01_B;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveMMX!()();
+
+		ulong a = 0x1234_5678_9ABC_DEF0_UL;
+		ulong b;
+
+		asm{
+			movq MM0, a;
+			movntq b, MM0;
+		}
+
+		if(a != 0x1234_5678_9ABC_DEF0_UL){
+			assert(0);
+		}
+		if(b != 0x1234_5678_9ABC_DEF0_UL){
+			assert(0);
+		}
+
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movq2dq_01.d
--- a/run/a/asm_movq2dq_01.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movq2dq_01.d	Thu May 18 16:07:06 2006 +0000
@@ -4,16 +4,26 @@
 
 module dstress.run.a.asm_movq2dq_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
-		static ulong[2] x = [0x0011_2233_4455_6677_8899LU, 0x1234_5678_90AB_CDEF];
-		ulong[2] y = x.dup;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE!()();
+
+		static ulong[2] X = [0x0011_2233_4455_6677_8899LU, 0x1234_5678_90AB_CDEF];
+		ulong[2] y = X.dup;
 		
 		static ulong A = 0x1234_ABCD_5678_EF01;
 		ulong a = A;
 		
 		asm{
-			movdqu XMM0, x;
+			movdqu XMM0, X;
 			movq MM0, a;
 			movq2dq XMM0, MM0;
 			movdqu y, XMM0;
@@ -32,8 +42,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movq_01_A.d
--- a/run/a/asm_movq_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movq_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,17 @@
 
 module dstress.run.a.asm_movq_01_A;
 
-int main(){
-	version(D_InlineAsm){
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE2!()();
 		
 		ulong a = 0x1234_ABCD_5678_EF01;
 		ulong b = 2;
@@ -15,12 +24,16 @@
 			movq b, MM0;
 		}
 		
-		assert(a==b);
-		assert(b==0x1234_ABCD_5678_EF01);
+		if(a != 0x1234_ABCD_5678_EF01){
+			assert(0);
+		}
+		if(b != 0x1234_ABCD_5678_EF01){
+			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);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movq_01_B.d
--- a/run/a/asm_movq_01_B.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movq_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movq_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!()();
+
 		static ulong[2] a = [0x1234_ABCD_56789_EF90_LU, 0x1122_5566_77AA_FFFF_LU];
 		ulong[2] b;
 		
@@ -26,8 +36,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movq_01_C.d
--- a/run/a/asm_movq_01_C.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movq_01_C.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,18 @@
 
 module dstress.run.a.asm_movq_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!()();
+
 		static ulong[2] a = [0x1234_ABCD_5678_EF90_LU, 0x1122_2222_5555_FFFF_LU];
 		static ulong[2] b = [0x1000_1111_5678_EF90_LU, 0x1122_5566_77AA_FFFF_LU];
 		
@@ -18,21 +28,21 @@
 			movdqu c, XMM0;
 		}
 		
-		if(c[0] == a[0]){
+		if(c[1] == a[1]){
 			// Intel
-		}else if(c[0] == 0){
+		}else if(c[1] == 0){
 			// AMD
 		}else{
 			assert(0);
 		}
 
-		if(c[1] != b[1]){
+		if(c[0] != b[0]){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsd_01.d
--- a/run/a/asm_movsd_01.d	Wed May 17 06:06:45 2006 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-// $HeadURL$
-// $Date$
-// $Author$
-
-module dstress.run.a.asm_movsd_01;
-
-int main(){
-	version(D_InlineAsm_X86){
-		
-		double a = -12.1L;
-		double b = 2.8L;
-		
-		asm{
-			movsd XMM0, a;
-			movsd b, XMM0;
-		}
-		
-		if(a != b){
-			assert(0);
-		}
-		
-		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
-	}
-}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsd_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movsd_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,36 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movsd_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 = [1.0, 2.0];
+		double b;
+		
+		asm{
+			movupd XMM0, A;
+			movsd b, XMM0;
+		}
+		
+		if(b != A[0]){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movshdup_01_A.d
--- a/run/a/asm_movshdup_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movshdup_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,33 +4,41 @@
 
 module dstress.run.a.asm_movshdup_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] a = [1.0, -1.0, -2.0, 2.0];
-		double[4] b;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		const float[4] a = [1.0f, -1.0f, -2.0f, 2.0f];
+		float[4] b;
 		
 		asm{
-			movdqu XMM0, a;
+			movups XMM0, a;
 			movshdup XMM1, XMM0;
-			movdqu b, XMM1;
+			movups b, XMM1;
 		}
 		
-		if(a[1] != b[0]){
+		if(a[0] != b[0]){
 			assert(0);
 		}
-		if(a[1] != b[1]){
+		if(a[0] != b[1]){
 			assert(0);
 		}
-		if(a[3] != b[2]){
+		if(a[2] != b[2]){
 			assert(0);
 		}
-		if(a[3] != b[3]){
+		if(a[2] != b[3]){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsldup_01_A.d
--- a/run/a/asm_movsldup_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movsldup_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,33 +4,43 @@
 
 module dstress.run.a.asm_movsldup_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] a = [1.0, -1.0, -2.0, 2.0];
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+
+	int main(){
+		haveSSE3!()();
+
+		const float[4] A = [1.0, -1.0f, -2.0f, 2.0f];
 		double[4] b;
 		
 		asm{
-			movdqu XMM0, a;
+			movups XMM0, A;
 			movsldup XMM1, XMM0;
-			movdqu b, XMM1;
+			movups b, XMM1;
 		}
 		
-		if(a[0] != b[0]){
+		if(A[1] != b[0]){
 			assert(0);
 		}
-		if(a[0] != b[1]){
+		if(A[1] != b[1]){
 			assert(0);
 		}
-		if(a[2] != b[2]){
+		if(A[3] != b[2]){
 			assert(0);
 		}
-		if(a[2] != b[3]){
+		if(A[3] != b[3]){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movss_01_A.d
--- a/run/a/asm_movss_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movss_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,34 +4,44 @@
 
 module dstress.run.a.asm_movss_01_A;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
-		const float B = 9.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];
+		const float B = 9.0f;
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
+			movups XMM0, A;
 			movss XMM0, B;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
 		if(c[0] != B){
 			assert(0);
 		}
-		if(c[1] != 0.0){
+		if(c[1] != 0.0f){
 			assert(0);
 		}
-		if(c[2] != 0.0){
+		if(c[2] != 0.0f){
 			assert(0);
 		}
-		if(c[3] != 0.0){
+		if(c[3] != 0.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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movss_01_B.d
--- a/run/a/asm_movss_01_B.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movss_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -4,20 +4,30 @@
 
 module dstress.run.a.asm_movss_01_B;
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
-		const float[4] B = [5.0, 6.0, 7.0, 9.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];
+		const float[4] B = [5.0f, 6.0f, 7.0f, 9.0f];
 		float[4] c;
 		
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			movss XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 		
-		if(c[0] != B[0]){
+		if(c[0] != A[0]){
 			assert(0);
 		}
 		if(c[1] != A[1]){
@@ -26,13 +36,13 @@
 		if(c[2] != A[2]){
 			assert(0);
 		}
-		if(c[3] != A[3]){
+		if(c[3] != B[3]){
 			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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movss_01_C.d
--- a/run/a/asm_movss_01_C.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movss_01_C.d	Thu May 18 16:07:06 2006 +0000
@@ -3,14 +3,23 @@
 // $Author$
 
 module dstress.run.a.asm_movss_01_C;
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
 
-int main(){
-	version(D_InlineAsm_X86){
-		const float[4] A = [1.0, 2.0, 3.0, 4.0];
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveSSE!()();
+		
+		const float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
 		float b;
 		
 		asm{
-			movdqu XMM0, A;
+			movups XMM0, A;
 			movss b, XMM0;
 		}
 		
@@ -19,8 +28,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsx_01_A.d
--- a/run/a/asm_movsx_01_A.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movsx_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_movsx_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(){
 		int i = 0xFF_FF_FF_FFu;
 		byte b = byte.min;
 		
@@ -35,8 +41,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);
 }
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsx_01_B.d
--- a/run/a/asm_movsx_01_B.d	Wed May 17 06:06:45 2006 +0000
+++ b/run/a/asm_movsx_01_B.d	Thu May 18 16:07:06 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_movsx_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 = 0x12_3F_FF_FFu;
 		byte b = -128;
 		
@@ -21,9 +27,9 @@
 		}
 
 		return 0;
-	}else{
-		pragma(msg, "no Inline asm support");
-		static assert(0);
 	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
 }
 
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_movsx_01_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_movsx_01_C.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,48 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_movsx_01_C;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	int main(){
+		int i = 0xFF_FF_FF_FFu;
+		short b = short.min;
+		
+		asm{
+			mov EAX, i;
+			mov AX, b;
+			movsx EAX, AX;
+			mov i, EAX;
+		}
+	
+		if(i != short.min){
+			assert(0);
+		}
+		
+		i = 0xFF_FF_FF_FFu;
+		b = short.max;
+		
+		asm{
+			mov EAX, i;
+			mov AX, b;
+			movsx EAX, AX;
+			mov i, EAX;
+		}
+		
+		if(i != short.max){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}
diff -r eb5364abce0c -r a7310ceac844 run/a/asm_stmxcsr_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_stmxcsr_01_A.d	Thu May 18 16:07:06 2006 +0000
@@ -0,0 +1,34 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_stmxcsr_01_A;
+
+version(D_InlineAsm_X86){
+	version = runTest;
+}else version(D_InlineAsm_X86_64){
+	version = runTest;
+}
+
+version(runTest){
+	import addon.cpuinfo;
+	
+	int main(){
+		haveMMX!()();
+
+		uint state;
+
+		asm{
+			stmxcsr state;
+		}
+
+		if((state & 0x0000_FFFF) != 0x0000_1F80){
+			assert(0);
+		}
+		
+		return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+	static assert(0);
+}