# HG changeset patch
# User thomask
# Date 1166713914 0
# Node ID 409746d4e24025e460355881f44ac4112e2fffa8
# Parent  516e1eeceb045b748044e60b737ec29e4f9c1fb3
32<->64 iasm fixes

diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_femms_01.d
--- a/run/a/asm_femms_01.d	Thu Dec 21 15:11:45 2006 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-// $HeadURL$
-// $Date$
-// $Author$
-
-module dstress.run.a.asm_femms_01;
-
-version(D_InlineAsm_X86){
-	version = runTest;
-}else version(D_InlineAsm_X86_64){
-	version = runTest;
-}
-
-version(runTest){
-	import addon.cpuinfo;
-	int main(){
-		have3DNow!()();
-		asm{
-			femms;
-		}
-		return 0;
-	}
-}else{
-	pragma(msg, "DSTRESS{XFAIL}: no inline ASM support");
-	static assert(0);
-}
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_fnsave_01.d
--- a/run/a/asm_fnsave_01.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_fnsave_01.d	Thu Dec 21 15:11:54 2006 +0000
@@ -24,7 +24,7 @@
 			static assert(0);
 		}
 
-		ubyte* state = new ubyte[stateSize];
+		ubyte* state = (new ubyte[stateSize]).ptr;
 
 		static if(size_t.sizeof == 4){
 			asm{
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_fsave_01.d
--- a/run/a/asm_fsave_01.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_fsave_01.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,15 +16,15 @@
 	int main(){
 		haveFPU!()();
 
-		static if(size_t.sizeof==4 || size_t.sizeof==8){
+		static if((size_t.sizeof == 4) || (size_t.sizeof == 8)){
 			ubyte stateSize = 108;
-		}else static if(size_t.sizeof==2){
+		}else static if(size_t.sizeof == 2){
 			ubyte stateSize = 94;
 		}else{
-			static assert(0);
+			static assert(0, "unhandled pointer size");
 		}
 
-		ubyte* state = new ubyte[stateSize];
+		ubyte* state = (new ubyte[stateSize]).ptr;
 
 		static if(size_t.sizeof == 4){
 			asm{
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_minsd_01_A.d
--- a/run/a/asm_minsd_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_minsd_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,21 +16,38 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 2.0;
 		a[1] = 4.0;
 
-		double[] b = new double[2];
+		double* b = (new double[2]).ptr;
 		b[0] = 1.0;
 		b[1] = 3.0;
 
-		double[] c = new double[2];
+		double* c = (new double[2]).ptr;
 
-		asm{
-			movupd XMM0, a;
-			movupd XMM1, b;
-			minsd XMM0, XMM1;
-			movupd c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				mov EAX, b;
+				movupd XMM1, [EAX];
+				minsd XMM0, XMM1;
+				mov EAX, c;
+				movupd [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				mov RAX, b;
+				movupd XMM1, [RAX];
+				minsd XMM0, XMM1;
+				mov RAX, c;
+				movupd [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 1.0){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_minsd_01_B.d
--- a/run/a/asm_minsd_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_minsd_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,32 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 3.0;
 		a[1] = 4.0;
 
 		double b = 2.0;
-		double[] c = new double[2];
+
+		double* c = (new double[2]).ptr;
 
-		asm{
-			movupd XMM0, a;
-			minsd XMM0, b;
-			movupd c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				minsd XMM0, b;
+				mov EAX, c;
+				movupd [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				minsd XMM0, b;
+				mov RAX, c;
+				movupd [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 2.0){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_minss_01_A.d
--- a/run/a/asm_minss_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_minss_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,25 +16,42 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 2.0f;
 		a[1] = 3.0f;
 		a[2] = 17.0f;
 		a[3] = -1.0f;
 
-		float[] b = new float[4];
+		float* b = (new float[4]).ptr;
 		b[0] = 1.0f;
 		b[1] = 4.0f;
 		b[2] = 16.0f;
 		b[3] = 1.0f;
 
-		float[] c = new float[4];
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movups XMM1, b;
-			minss XMM0, XMM1;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movups XMM1, [EAX];
+				minss XMM0, XMM1;
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movups XMM1, [RAX];
+				minss XMM0, XMM1;
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 1.0f){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_minss_01_B.d
--- a/run/a/asm_minss_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_minss_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,19 +16,34 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 2.0f;
 		a[1] = 3.0f;
 		a[2] = 17.0f;
 		a[3] = -1.0f;
 
 		float b = 1.0f;
-		float[] c = new float[4];
+
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			minss XMM0, b;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				minss XMM0, b;
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				minss XMM0, b;
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 1.0f){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movapd_01_A.d
--- a/run/a/asm_movapd_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movapd_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,15 +16,30 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 2.0;
 		a[1] = 3.0;
-		double[] b = new double[2];
+
+		double* b = (new double[2]).ptr;
 
-		asm{
-			movdqu XMM0, a;
-			movapd XMM1, XMM0;
-			movdqu b, XMM1;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movdqu XMM0, [EAX];
+				movapd XMM1, XMM0;
+				mov EAX, b;
+				movdqu [EAX], XMM1;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movdqu XMM0, [RAX];
+				movapd XMM1, XMM0;
+				mov RAX, b;
+				movdqu [RAX], XMM1;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(a[0] != b[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movaps_01_A.d
--- a/run/a/asm_movaps_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movaps_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,18 +16,32 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 2.0f;
 		a[1] = 3.0f;
 		a[2] = 0.0f;
 		a[3] = 0.5f;
 
-		float[] b = new float[4];
+		float* b = (new float[4]).ptr;
 
-		asm{
-			movdqu XMM0, a;
-			movaps XMM1, XMM0;
-			movdqu b, XMM1;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movdqu XMM0, [EAX];
+				movaps XMM1, XMM0;
+				mov EAX, b;
+				movdqu [EAX], XMM1;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movdqu XMM0, [RAX];
+				movaps XMM1, XMM0;
+				mov RAX, b;
+				movdqu [RAX], XMM1;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(a[0] != b[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movddup_01_A.d
--- a/run/a/asm_movddup_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movddup_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,32 @@
 	int main(){
 		haveSSE3!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 2.0;
 		a[1] = 3.0;
 
-		double[] b = new double[2];
+		double* b = (new double[2]).ptr;
 
-		asm{
-			movupd XMM0, a;
-			movupd XMM1, a;
-			movddup XMM1, XMM0;
-			movupd b, XMM1;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				movupd XMM1, [EAX];
+				movddup XMM1, XMM0;
+				mov EAX, b;
+				movupd [EAX], XMM1;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				movupd XMM1, [RAX];
+				movddup XMM1, XMM0;
+				mov RAX, b;
+				movupd [RAX], XMM1;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(a[0] != b[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movddup_01_B.d
--- a/run/a/asm_movddup_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movddup_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,32 @@
 	int main(){
 		haveSSE3!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 2.0;
 		a[1] = 3.0;
 
-		double[] b = new double[2];
+		double* b = (new double[2]).ptr;
+
 		double c = 1.0;
 
-		asm{
-			movupd XMM0, a;
-			movddup XMM0, c;
-			movupd b, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				movddup XMM0, c;
+				mov EAX, b;
+				movupd [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				movddup XMM0, c;
+				mov RAX, b;
+				movupd [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b[0] != 1.0){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movhpd_01_A.d
--- a/run/a/asm_movhpd_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movhpd_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,32 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 1.0;
 		a[1] = 2.0;
 
 		double b = 4.0;
-		double[] c = new double[2];
+
+		double* c = (new double[2]).ptr;
 
-		asm{
-			movupd XMM0, a;
-			movhpd XMM0, b;
-			movupd c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				movhpd XMM0, b;
+				mov EAX, c;
+				movupd [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				movhpd XMM0, b;
+				mov RAX, c;
+				movupd [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != a[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movhpd_01_B.d
--- a/run/a/asm_movhpd_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movhpd_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,15 +16,26 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 1.0;
 		a[1] = 2.0;
 
 		double b;
 
-		asm{
-			movupd XMM0, a;
-			movhpd b, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				movhpd b, XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				movhpd b, XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b != a[1]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movhps_01_A.d
--- a/run/a/asm_movhps_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movhps_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,22 +16,38 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 1.0f;
 		a[1] = 2.0f;
 		a[2] = 3.0f;
 		a[3] = 4.0f;
 
-		float[] b = new float[2];
+		float* b = (new float[2]).ptr;
 		b[0] = 5.0f;
 		b[1] = 6.0f;
 
-		float[] c = new float[4];
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movhps XMM0, b;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movhps XMM0, [EAX];
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movhps XMM0, [RAX];
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != a[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movhps_01_B.d
--- a/run/a/asm_movhps_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movhps_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,16 +16,30 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 1.0f;
 		a[1] = 2.0f;
 		a[2] = 3.0f;
 		a[3] = 4.0f;
-		float[] b = new float[2];
+
+		float* b = (new float[2]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movhps b, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movhps [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movhps [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b[0] != a[2]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movlhps_01_A.d
--- a/run/a/asm_movlhps_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movlhps_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,25 +16,42 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 3.0f;
 		a[1] = 4.0f;
 		a[2] = 5.0f;
 		a[3] = 6.0f;
 
-		float[] b = new float[4];
+		float* b = (new float[4]).ptr;
 		b[0] = 10.0f;
 		b[1] = 20.0f;
 		b[2] = 30.0f;
 		b[3] = 40.0f;
 
-		float[] c = new float[4];
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movups XMM1, b;
-			movlhps XMM0, XMM1;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movups XMM1, [EAX];
+				movlhps XMM0, XMM1;
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movups XMM1, [RAX];
+				movlhps XMM0, XMM1;
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != a[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movlpd_01_A.d
--- a/run/a/asm_movlpd_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movlpd_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,18 +16,32 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 3.0;
 		a[1] = 4.0;
 
 		double b = 5.0;
 
-		double[] c = new double[2];
+		double* c = (new double[2]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movlpd XMM0, b;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				movlpd XMM0, b;
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				movlpd XMM0, b;
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != b){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movlpd_01_B.d
--- a/run/a/asm_movlpd_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movlpd_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,15 +16,27 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 3.0;
 		a[1] = 4.0;
 
 		double b = 5.0;
 
-		asm{
-			movups XMM0, a;
-			movlpd b, XMM0;
+
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				movlpd b, XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				movlpd b, XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b != a[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movlps_01_A.d
--- a/run/a/asm_movlps_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movlps_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,22 +16,38 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 1.0f;
 		a[1] = 2.0f;
 		a[2] = 3.0f;
 		a[3] = 4.0f;
 
-		float[] b = new float[2];
+		float* b = (new float[2]).ptr;
 		b[0] = 5.0f;
 		b[1] = 6.0f;
 
-		float[] c = new float[4];
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movlps XMM0, b;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movlps XMM0, [EAX];
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movlps XMM0, [RAX];
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != b[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movlps_01_B.d
--- a/run/a/asm_movlps_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movlps_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,30 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 1.0f;
 		a[1] = 2.0f;
 		a[2] = 3.0f;
 		a[3] = 4.0f;
 
-		float[] b = new float[2];
+		float* b = (new float[2]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movlps b, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movlps [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movlps [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b[0] != a[0]){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movmskpd_01_A.d
--- a/run/a/asm_movmskpd_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movmskpd_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,17 +16,31 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 1.0;
 		a[1] = -1.0;
 
 		uint b;
 
-		asm{
-			movupd XMM0, a;
-			mov EAX, 0x1234_5678;
-			movmskpd EAX, XMM0;
-			mov b, EAX;
+
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				mov EAX, 0x1234_5678;
+				movmskpd EAX, XMM0;
+				mov b, EAX;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				mov RAX, 0x1234_5678;
+				movmskpd RAX, XMM0;
+				mov b, RAX;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b != 0x0000_0002){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movmskps_01_A.d
--- a/run/a/asm_movmskps_01_A.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movmskps_01_A.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,7 +16,7 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 1.0f;
 		a[1] = -1.0f;
 		a[2] = -float.infinity;
@@ -24,11 +24,24 @@
 
 		uint b;
 
-		asm{
-			movdqu XMM0, a;
-			mov EAX, 0x1234_5678;
-			movmskps EAX, XMM0;
-			mov b, EAX;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movdqu XMM0, [EAX];
+				mov EAX, 0x1234_5678;
+				movmskps EAX, XMM0;
+				mov b, EAX;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movdqu XMM0, [RAX];
+				mov RAX, 0x1234_5678;
+				movmskps RAX, XMM0;
+				mov b, RAX;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(b != 0b1110){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_movq_02_O.d
--- a/run/a/asm_movq_02_O.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_movq_02_O.d	Thu Dec 21 15:11:54 2006 +0000
@@ -22,16 +22,28 @@
 	int main(){
 		haveSSE2!()();
 
-		const long A = 0x12_34_56_78_9A_BC_DE_F0;
+		long a = 0x12_34_56_78_9A_BC_DE_F0;
 		long b;
 
-		asm{
-			movq MM0, A;
-			movq b, MM0;
-			emms;
+		static if(size_t.sizeof == 4){
+			asm{
+				lea EAX, a;
+				movq MM0, [EAX];
+				movq b, MM0;
+				emms;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				lea RAX, a;
+				movq MM0, [RAX];
+				movq b, MM0;
+				emms;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
-		if(A != 0x12_34_56_78_9A_BC_DE_F0){
+		if(a != 0x12_34_56_78_9A_BC_DE_F0){
 			assert(0);
 		}
 		if(b != 0x12_34_56_78_9A_BC_DE_F0){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_mulpd_01_B.d
--- a/run/a/asm_mulpd_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_mulpd_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,21 +16,38 @@
 	int main(){
 		haveSSE2!()();
 
-		double[] a = new double[2];
+		double* a = (new double[2]).ptr;
 		a[0] = 7.0;
 		a[1] = 4.0;
 
-		double[] b = new double[2];
+		double* b = (new double[2]).ptr;
 		b[0] = 3.0;
 		b[1] = 2.0;
 
-		double[] c = new double[2];
-
-		asm{
-			movupd XMM0, a;
-			movupd XMM1, b;
-			mulpd XMM0, XMM1;
-			movupd c, XMM0;
+		double* c = (new double[2]).ptr;
+	
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movupd XMM0, [EAX];
+				mov EAX, b;
+				movupd XMM1, [EAX];
+				mulpd XMM0, XMM1;
+				mov EAX, c;
+				movupd [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movupd XMM0, [RAX];
+				mov RAX, b;
+				movupd XMM1, [RAX];
+				mulpd XMM0, XMM1;
+				mov RAX, c;
+				movupd [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 21.0){
diff -r 516e1eeceb04 -r 409746d4e240 run/a/asm_mulps_01_B.d
--- a/run/a/asm_mulps_01_B.d	Thu Dec 21 15:11:45 2006 +0000
+++ b/run/a/asm_mulps_01_B.d	Thu Dec 21 15:11:54 2006 +0000
@@ -16,25 +16,42 @@
 	int main(){
 		haveSSE!()();
 
-		float[] a = new float[4];
+		float* a = (new float[4]).ptr;
 		a[0] = 7.0f;
 		a[1] = 4.0f;
 		a[2] = 1.0f;
 		a[3] = -2.0f;
 
-		float[] b = new float[4];
+		float* b = (new float[4]).ptr;
 		b[0] = 3.0f;
 		b[1] = 2.0f;
 		b[2] = 0.0f;
 		b[3] = 5.0f;
 
-		float[] c = new float[4];
+		float* c = (new float[4]).ptr;
 
-		asm{
-			movups XMM0, a;
-			movups XMM1, b;
-			mulps XMM0, XMM1;
-			movups c, XMM0;
+		static if(size_t.sizeof == 4){
+			asm{
+				mov EAX, a;
+				movups XMM0, [EAX];
+				mov EAX, b;
+				movups XMM1, [EAX];
+				mulps XMM0, XMM1;
+				mov EAX, c;
+				movups [EAX], XMM0;
+			}
+		}else static if(size_t.sizeof == 8){
+			asm{
+				mov RAX, a;
+				movups XMM0, [RAX];
+				mov RAX, b;
+				movups XMM1, [RAX];
+				mulps XMM0, XMM1;
+				mov RAX, c;
+				movups [RAX], XMM0;
+			}
+		}else{
+			static assert(0, "unhandled pointer size");
 		}
 
 		if(c[0] != 21.0f){