# HG changeset patch
# User thomask
# Date 1147016264 0
# Node ID 1c9d1337cb77da5cbf9118cad75eaa7a582c9e5d
# Parent  c6f4a1d578923dde3f477bbe5808b81e7cc3e16e
inline asm review

diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_A.d
--- a/run/a/asm_adc_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_adc_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		byte a = 3;
 		byte b = 5;
 				
@@ -32,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_B.d
--- a/run/a/asm_adc_01_B.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_adc_01_B;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		short a = 300;
 		short b = 500;
 				
@@ -32,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_C.d
--- a/run/a/asm_adc_01_C.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_C.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_adc_01_C;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		int a = 30000;
 		int b = 50000;
 				
@@ -32,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_D.d
--- a/run/a/asm_adc_01_D.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_D.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_D;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		byte a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_E.d
--- a/run/a/asm_adc_01_E.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_E.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_E;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		short a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_F.d
--- a/run/a/asm_adc_01_F.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_F.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_F;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		int a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_H.d
--- a/run/a/asm_adc_01_H.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_H.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_H;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		byte a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_I.d
--- a/run/a/asm_adc_01_I.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_I.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_I;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		short a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_adc_01_J.d
--- a/run/a/asm_adc_01_J.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_adc_01_J.d	Sun May 07 15:37:44 2006 +0000
@@ -2,12 +2,16 @@
 // $Date$
 // $Author$
 
-// __DSTRESS_REQUIRE__ D_InlineAsm_X86
-
 module dstress.run.a.asm_adc_01_J;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		int a;
 				
 		asm{
@@ -34,7 +38,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_01_A.d
--- a/run/a/asm_add_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_add_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -5,7 +5,7 @@
 module dstress.run.a.asm_add_01_A;
 
 int main(){
-	version(D_InlineAsm){
+	version(D_InlineAsm_X86){
 		uint i = 0x12_23_45_56;
 		ubyte b = 0xFFu;
 		
@@ -24,7 +24,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_01_B.d
--- a/run/a/asm_add_01_B.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_add_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_add_01_B;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint i = 0x12_23_45_56u;
 		ushort s = 0xFFFFu;
 		
@@ -24,7 +30,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_01_C.d
--- a/run/a/asm_add_01_C.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_add_01_C.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_add_01_C;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint i = 0x12_23_45_56u;
 		uint s = 0xFF_FF_FF_FFu;
 		
@@ -23,7 +29,7 @@
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_02.d
--- a/run/a/asm_add_02.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_add_02.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,28 @@
  
 module dstress.run.a.asm_add_02;
 
-int test(int i){
-	asm{
-		naked;
-		add	EAX, 1;
-		ret;
-	}
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
 }
 
-int main(){
-	assert(test(1)==2);
-	assert(test(2)==3);
-	assert(test(3)==4);
-        return 0;
-}
\ No newline at end of file
+version(doTest){
+	int test(int i){
+		asm{
+			naked;
+			add	EAX, 1;
+			ret;
+		}
+	}
+
+	int main(){
+		assert(test(1)==2);
+		assert(test(2)==3);
+		assert(test(3)==4);
+        	return 0;
+	}
+}else{
+	pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+	static assert(0);
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_03_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_03_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,31 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_03_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		int i = 0x12_34_56_FF;
+		asm{
+			mov EAX, i;
+			add AL, 2;
+			mov i, EAX;
+		}
+
+		if(i != 0x12_34_56_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_03_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_03_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,31 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_03_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		int i = 0x12_34_FF_FF;
+		asm{
+			mov EAX, i;
+			add AX, 2;
+			mov i, EAX;
+		}
+
+		if(i != 0x12_34_00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_03_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_03_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,31 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_03_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(D_InlineAsm_X86){
+		int i = 0x12_34_FF_FF;
+		asm{
+			mov EAX, i;
+			add EAX, 2;
+			mov i, EAX;
+		}
+
+		if(i != 0x12_35_00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_04_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_04_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_04_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		int i = 0x12_34_FF_FF;
+		asm{
+			mov EAX, 2;
+			add i, EAX;
+		}
+
+		if(i != 0x12_35_00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_04_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_04_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_04_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort i = 0xFF_FF;
+		asm{
+			mov AX, 2;
+			add i, AX;
+		}
+
+		if(i != 0x00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_04_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_04_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,30 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_04_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ubyte i = 0xFF;
+		asm{
+			mov AL, 2;
+			add i, AL;
+		}
+
+		if(i != 0x01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_05_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_05_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_05_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ubyte i = 4;
+		asm{
+			mov BL, 0xFF;
+			mov AL, 2;
+			add AL, BL;
+			mov i, AL;
+		}
+
+		if(i != 0x01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_05_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_05_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_05_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort i = 4;
+		asm{
+			mov BX, 0xFF_FF;
+			mov AX, 2;
+			add AX, BX;
+			mov i, AX;
+		}
+
+		if(i != 0x00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_add_05_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_add_05_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.add_05_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint i = 4;
+		asm{
+			mov EBX, 0xFF_FF_FF_FF;
+			mov EAX, 2;
+			add EAX, EBX;
+			mov i, EAX;
+		}
+
+		if(i != 0x00_00_00_01){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_addps_01_A.d
--- a/run/a/asm_addps_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_addps_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,23 @@
 
 module dstress.run.a.asm_addps_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		static float[4] A = [1.0f, 20.0f, 0.4f, 1.0f];
 		static float[4] B = [4.0f, 10.0f, 4.0f, -1.0f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			addps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		c[0] -= 5.0f;
@@ -53,7 +59,7 @@
 		}
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no Inline asm support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_addsd_01_A.d
--- a/run/a/asm_addsd_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_addsd_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,23 @@
 
 module dstress.run.a.asm_addsd_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		static double[2] A = [1.0, 20.0];
 		static double[2] B = [4.0, 10.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			addsd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		c[0] -= 5.0;
@@ -33,7 +39,7 @@
 
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_addss_01_A.d
--- a/run/a/asm_addss_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_addss_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,23 @@
 
 module dstress.run.a.asm_addss_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		static float[4] A = [1.0f, 20.0f, 0.4f, 2.0f];
 		static float[4] B = [4.0f, 10.0f, -4.0f, -0.4f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			addss XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		c[0] -= 5.0f;
@@ -54,7 +60,7 @@
 		}
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XPASS}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_addsubpd_01_A.d
--- a/run/a/asm_addsubpd_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_addsubpd_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,23 @@
 
 module dstress.run.a.asm_addsubpd_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		static double[2] A = [1.0, 30.0];
 		static double[2] B = [4.0, 10.0];
 		double[2] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movupd XMM0, A;
+			movupd XMM1, B;
 			addsubpd XMM0, XMM1;
-			movdqu c, XMM0;
+			movupd c, XMM0;
 		}
 
 		c[0] += 3.0;
@@ -36,7 +42,7 @@
 		}
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_addsubps_01_A.d
--- a/run/a/asm_addsubps_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_addsubps_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,17 +4,23 @@
 
 module dstress.run.a.asm_addsubps_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm_X86){
+	version(doTest){
 		static float[4] A = [1.0f, 2.0f, 3.0f, 4.0f];
 		static float[4] B = [0.1f, 0.2f, 0.3f, 0.4f];
 		float[4] c;
 
 		asm{
-			movdqu XMM0, A;
-			movdqu XMM1, B;
+			movups XMM0, A;
+			movups XMM1, B;
 			addsubps XMM0, XMM1;
-			movdqu c, XMM0;
+			movups c, XMM0;
 		}
 
 		c[0] -= 0.9f;
@@ -54,7 +60,7 @@
 		}
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
 }
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_01.d
--- a/run/a/asm_and_01.d	Wed May 03 04:54:22 2006 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
- // $HeadURL$
- // $Date$
- // $Author$
- 
-module dstress.run.a.asm_and_01;
-
-int test(int i){
-	asm{
-		mov	EAX, i;
-		and	EAX, EAX;
-		mov 	i, EAX;
-	}
-}
-
-int main(){
-	assert(test(7)==7);
-	assert(test(0)==0);
-        return 0;
-}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_01_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ubyte b = 5;
+		asm{
+			mov EAX, a;
+			and AL, b;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_56_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ushort b = 5;
+		asm{
+			mov EAX, a;
+			and AX, b;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_00_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_01_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_01_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_01_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		uint b = 0x12_30_43_01;
+		asm{
+			mov EAX, a;
+			and EAX, b;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_30_42_00){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ubyte b = 5;
+		asm{
+			mov EBX, a;
+			and BL, b;
+			mov a, EBX;
+		}
+		
+		if(a != 0x12_34_56_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ushort b = 5;
+		asm{
+			mov EBX, a;
+			and BX, b;
+			mov a, EBX;
+		}
+		
+		if(a != 0x12_34_00_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_02_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_02_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_02_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		uint b = 0x12_30_43_01;
+		asm{
+			mov EBX, a;
+			and EBX, b;
+			mov a, EBX;
+		}
+		
+		if(a != 0x12_30_42_00){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_03_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_03_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_03_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ushort b = 0x43_01;
+		asm{
+			mov EAX, a;
+			and AX, b;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_42_00){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_03_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_03_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_03_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ubyte b = 0x05;
+		asm{
+			mov EAX, a;
+			and AL, b;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_56_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_04_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_04_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,33 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_04_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ubyte b = 0x05;
+		asm{
+			mov EAX, a;
+			mov BL, b;
+			and AL, BL;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_56_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_04_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_04_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,33 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_04_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		ushort b = 0x41_05;
+		asm{
+			mov EAX, a;
+			mov BX, b;
+			and AX, BX;
+			mov a, EAX;
+		}
+		
+		if(a != 0x12_34_40_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_and_04_C.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_and_04_C.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,33 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_and_04_C;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x12_34_56_06;
+		uint b = 0x02_12_41_05;
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			and EAX, EBX;
+			mov a, EAX;
+		}
+		
+		if(a != 0x02_10_40_04){
+			assert(0);
+		}
+
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsf_01_A.d
--- a/run/a/asm_bsf_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_bsf_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_bsf_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		ushort a = 0x3000;
 		
 		asm{
@@ -13,11 +19,13 @@
 			mov a, AX;
 		}
 		
-		assert(a==12);
+		if(a!=12){
+			assert(0);
+		}
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsf_01_B.d
--- a/run/a/asm_bsf_01_B.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_bsf_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_bsf_01_B;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint a = 0x30000;
 		
 		asm{
@@ -13,11 +19,13 @@
 			mov a, EAX;
 		}
 		
-		assert(a==16);
+		if(a != 16){
+			assert(0);
+		 }
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsf_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bsf_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_bsf_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 0x3000;
+		
+		asm{
+			mov BX, a;
+			bsf AX, BX;
+			mov a, AX;
+		}
+		
+		if(a != 12){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsf_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bsf_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_bsf_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x30000;
+		
+		asm{
+			mov EBX, a;
+			bsf EAX, EBX;
+			mov a, EAX;
+		}
+		
+		if(a != 16){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsr_01_A.d
--- a/run/a/asm_bsr_01_A.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_bsr_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_bsr_01_A;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint a = 0x30000;
 		
 		asm{
@@ -13,11 +19,13 @@
 			mov a, EAX;
 		}
 		
-		assert(a==17);
+		if(a != 17){
+			assert(0);
+		}
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsr_01_B.d
--- a/run/a/asm_bsr_01_B.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_bsr_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_bsr_01_B;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		ushort a = 0x3000;
 		
 		asm{
@@ -13,11 +19,13 @@
 			mov a, AX;
 		}
 		
-		assert(a==13);
+		if(a != 13){
+			assert(0);
+		}
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsr_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bsr_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_bsr_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 0x30000;
+		
+		asm{
+			mov EBX, a;
+			bsr EAX, EBX;
+			mov a, EAX;
+		}
+		
+		if(a != 17){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bsr_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bsr_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,32 @@
+// $HeadURL$
+// $Date$
+// $Author$
+
+module dstress.run.a.asm_bsr_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 0x3000;
+		
+		asm{
+			mov BX, a;
+			bsr AX, BX;
+			mov a, AX;
+		}
+		
+		if(a != 13){
+			assert(0);
+		}
+		
+		return 0;
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bswap_01.d
--- a/run/a/asm_bswap_01.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_bswap_01.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_bswp_01;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint a = 0xAB_34_56_78;
 		
 		asm{
@@ -14,11 +20,13 @@
 			mov a, EAX;
 		}
 		
-		assert(a==0x78_56_34_AB);
+		if(a!=0x78_56_34_AB){
+			assert(0);
+		}
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bt_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bt_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,35 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bt_01_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 0x00_01;
+		ushort b = 0x00_00;
+
+		asm{
+			mov AX, a;
+			mov BX, b;
+			bt  AX, BX;
+			jnc error;
+			mov BX, AX;
+			bt  AX, BX;
+			jc error;
+		}
+		
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bt_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bt_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,34 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bt_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 0x00_01;
+		ushort b = 0x00_00;
+
+		asm{
+			mov BX, b;
+			bt  a, BX;
+			jnc error;
+			mov BX, a;
+			bt  a, BX;
+			jc error;
+		}
+		
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bt_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bt_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,35 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bt_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 1;
+		uint b = 0;
+
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			bt  EAX, EBX;
+			jnc error;
+			mov EBX, EAX;
+			bt  EAX, EBX;
+			jc error;
+		}
+		
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bt_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bt_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,34 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bt_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 1;
+		uint b = 0;
+
+		asm{
+			mov EBX, b;
+			bt  a, EBX;
+			jnc error;
+			mov EBX, a;
+			bt  a, EBX;
+			jc error;
+		}
+		
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btc_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btc_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btc_01_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 3;
+		ushort b = 0;
+
+		asm{
+			mov BX, b;
+			btc a, BX;
+			jnc error;
+			btc a, BX;
+			jc error;
+			btc a, BX;
+			jnc error;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btc_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btc_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btc_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 3;
+		ushort b = 0;
+
+		asm{
+			mov AX, a;
+			mov BX, b;
+			btc AX, BX;
+			jnc error;
+			btc AX, BX;
+			jc error;
+			btc AX, BX;
+			jnc error;
+			mov a, AX;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btc_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btc_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btc_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 3;
+		uint b = 0;
+
+		asm{
+			mov EBX, b;
+			btc a, EBX;
+			jnc error;
+			btc a, EBX;
+			jc error;
+			btc a, EBX;
+			jnc error;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btc_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btc_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btc_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 3;
+		uint b = 0;
+
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			btc EAX, EBX;
+			jnc error;
+			btc EAX, EBX;
+			jc error;
+			btc EAX, EBX;
+			jnc error;
+			mov a, EAX;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btr_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btr_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btr_01_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 3;
+		ushort b = 0;
+
+		asm{
+			mov BX, b;
+			btr a, BX;
+			jnc error;
+			btr a, BX;
+			jc error;
+			btr a, BX;
+			jc error;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btr_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btr_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btr_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 3;
+		ushort b = 0;
+
+		asm{
+			mov AX, a;
+			mov BX, b;
+			btr AX, BX;
+			jnc error;
+			btr AX, BX;
+			jc error;
+			btr AX, BX;
+			jc error;
+			mov a, AX;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btr_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btr_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btr_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 3;
+		uint b = 0;
+
+		asm{
+			mov EBX, b;
+			btr a, EBX;
+			jnc error;
+			btr a, EBX;
+			jc error;
+			btr a, EBX;
+			jc error;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_btr_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_btr_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_btr_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 3;
+		uint b = 0;
+
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			btr EAX, EBX;
+			jnc error;
+			btr EAX, EBX;
+			jc error;
+			btr EAX, EBX;
+			jc error;
+			mov a, EAX;
+		}
+		
+		if(a != 2){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bts_01_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bts_01_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bts_01_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 2;
+		ushort b = 0;
+
+		asm{
+			mov BX, b;
+			bts a, BX;
+			jc error;
+			bts a, BX;
+			jnc error;
+			bts a, BX;
+			jnc error;
+		}
+		
+		if(a != 3){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bts_01_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bts_01_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bts_01_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		ushort a = 2;
+		ushort b = 0;
+
+		asm{
+			mov AX, a;
+			mov BX, b;
+			bts AX, BX;
+			jc error;
+			bts AX, BX;
+			jnc error;
+			bts AX, BX;
+			jnc error;
+			mov a, AX;
+		}
+		
+		if(a != 3){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bts_02_A.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bts_02_A.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,39 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bts_02_A;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 2;
+		uint b = 0;
+
+		asm{
+			mov EBX, b;
+			bts a, EBX;
+			jc error;
+			bts a, EBX;
+			jnc error;
+			bts a, EBX;
+			jnc error;
+		}
+		
+		if(a != 3){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_bts_02_B.d
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/run/a/asm_bts_02_B.d	Sun May 07 15:37:44 2006 +0000
@@ -0,0 +1,41 @@
+ // $HeadURL$
+ // $Date$
+ // $Author$
+ 
+module dstress.run.a.asm_bts_02_B;
+
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
+int main(){
+	version(doTest){
+		uint a = 2;
+		uint b = 0;
+
+		asm{
+			mov EAX, a;
+			mov EBX, b;
+			bts EAX, EBX;
+			jc error;
+			bts EAX, EBX;
+			jnc error;
+			bts EAX, EBX;
+			jnc error;
+			mov a, EAX;
+		}
+		
+		if(a != 3){
+			assert(0);
+		}
+
+		return 0;
+	error:
+		assert(0);
+	}else{
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
+		static assert(0);
+	}
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_cbw_01.d
--- a/run/a/asm_cbw_01.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_cbw_01.d	Sun May 07 15:37:44 2006 +0000
@@ -4,13 +4,17 @@
 
 module dstress.run.a.asm_cbw_01;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint i=0x12_3F_FF_FFu;
 		byte b=-128;
 		
-		assert(i==0x12_3F_FF_FFu);
-		
 		asm{
 			mov EAX, i;
 			mov AL, b;
@@ -18,11 +22,13 @@
 			mov i, EAX;
 		}
 	
-		assert(i== 0x12_3F_FF_80u);
+		if(i != 0x12_3F_FF_80u){
+			assert(0);
+		}
 
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_clc_01.d
--- a/run/a/asm_clc_01.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_clc_01.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_clc_01;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint a;
 		
 		asm{
@@ -19,11 +25,13 @@
 			mov a, EAX;
 		}
 	
-		assert(a==3);
+		if(a != 3){
+			assert(0);
+		}
 		
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
-}
\ No newline at end of file
+}
diff -r c6f4a1d57892 -r 1c9d1337cb77 run/a/asm_cwde_01.d
--- a/run/a/asm_cwde_01.d	Wed May 03 04:54:22 2006 +0000
+++ b/run/a/asm_cwde_01.d	Sun May 07 15:37:44 2006 +0000
@@ -4,8 +4,14 @@
 
 module dstress.run.a.asm_cwde_01;
 
+version(D_InlineAsm_X86){
+	version = doTest;
+}else version(D_InlineAsm_X86_64){
+	version = doTest;
+}
+
 int main(){
-	version(D_InlineAsm){
+	version(doTest){
 		uint i=0x12_3F_FF_FFu;
 		short s=-128;
 		
@@ -18,12 +24,14 @@
 			mov i, EAX;
 		}
 	
-		assert(i==0xFF_FF_FF_80u);
+		if(i != 0xFF_FF_FF_80u){
+			assert(0);
+		}
 		
 
 		return 0;
 	}else{
-		pragma(msg, "no Inline asm support");
+		pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
 		static assert(0);
 	}
 }