Mercurial > projects > dstress
changeset 1151:2a1a6610f7ad
various inline assembler fixes
line wrap: on
line diff
--- a/run/a/asm_adc_01_H.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_adc_01_H.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_adc_01_H; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_adc_01_I.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_adc_01_I.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_adc_01_I; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_adc_01_J.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_adc_01_J.d Mon Sep 25 11:38:19 2006 +0000 @@ -2,6 +2,8 @@ // $Date$ // $Author$ +// __DSTRESS_TORTURE_BLOCK__ -fPIC + module dstress.run.a.asm_adc_01_J; version(D_InlineAsm_X86){
--- a/run/a/asm_add_05_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_add_05_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.add_05_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_add_05_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_add_05_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.add_05_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_add_05_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_add_05_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -2,6 +2,8 @@ // $Date$ // $Author$ +// __DSTRESS_TORTURE_BLOCK__ -fPIC + module dstress.run.a.add_05_C; version(D_InlineAsm_X86){
--- a/run/a/asm_addpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,13 +24,26 @@ b[0] = 0.0012; b[1] = -2.4; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - addpd XMM0, XMM1; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + addpd XMM0, XMM1; + movupd [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + mov RAX, b; + movupd XMM1, [RAX]; + addpd XMM0, XMM1; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] -= 1.1242;
--- a/run/a/asm_addps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -28,13 +28,26 @@ b[2] = 4.0f; b[3] = -1.0f; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - addps XMM0, XMM1; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + addps XMM0, XMM1; + movups [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + mov RAX, b; + movups XMM1, [RAX]; + addps XMM0, XMM1; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] -= 5.0f;
--- a/run/a/asm_addsd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addsd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,13 +24,26 @@ b[0] = 4.0; b[1] = 10.0; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - addsd XMM0, XMM1; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + addsd XMM0, XMM1; + movupd [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + mov RAX, b; + movupd XMM1, [RAX]; + addsd XMM0, XMM1; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] -= 5.0;
--- a/run/a/asm_addss_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addss_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -28,13 +28,26 @@ b[2] = -4.0f; b[3] = -0.4f; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - addss XMM0, XMM1; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + addss XMM0, XMM1; + movups [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + mov RAX, b; + movups XMM1, [RAX]; + addss XMM0, XMM1; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] -= 5.0f;
--- a/run/a/asm_addsubpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addsubpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,13 +24,26 @@ b[0] = 4.0; b[1] = 10.0; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - addsubpd XMM0, XMM1; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + addsubpd XMM0, XMM1; + movupd [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + mov RAX, b; + movupd XMM1, [RAX]; + addsubpd XMM0, XMM1; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] += 3.0;
--- a/run/a/asm_addsubps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_addsubps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -28,13 +28,26 @@ b[2] = 0.3f; b[3] = 0.4f; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - addsubps XMM0, XMM1; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + addsubps XMM0, XMM1; + movups [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + mov RAX, b; + movups XMM1, [RAX]; + addsubps XMM0, XMM1; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] -= 0.9f;
--- a/run/a/asm_and_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_and_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_and_02_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_02_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_02_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_and_04_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_04_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_04_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_and_04_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_04_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_04_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_and_04_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_and_04_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_and_04_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bl_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bl_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bl_01; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bsf_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bsf_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bsf_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bsf_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bsf_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bsf_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bsr_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bsr_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bsr_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bsr_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bsr_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bsr_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bt_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bt_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bt_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bt_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bt_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bt_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bt_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bt_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bt_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bt_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bt_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bt_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btc_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btc_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btc_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btc_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btc_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btc_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btc_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btc_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btc_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btc_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btc_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btc_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btr_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btr_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btr_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btr_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btr_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btr_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btr_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btr_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btr_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_btr_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_btr_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_btr_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bts_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bts_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bts_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bts_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bts_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bts_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bts_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bts_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bts_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bts_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bts_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bts_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bx_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bx_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bx_01; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_bx_02.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_bx_02.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_bx_02; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_clflush_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_clflush_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_clflush_01; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmova_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmova_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmova_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmova_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmova_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmova_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmova_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmova_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmova_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmova_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmova_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmova_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmppd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmppd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ ulong* c = new ulong[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - cmppd XMM0, XMM1, 0; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + cmppd XMM0, XMM1, 0; + 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]; + cmppd XMM0, XMM1, 0; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0]){
--- a/run/a/asm_cmpps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -30,16 +30,29 @@ uint* c = new uint[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - cmpps XMM0, XMM1, 0; - mov EAX, c; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + cmpps XMM0, XMM1, 0; + 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]; + cmpps XMM0, XMM1, 0; + mov RAX, c; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } - if(c[0]){ assert(0); }
--- a/run/a/asm_cmpsd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpsd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -27,16 +27,32 @@ ulong* c = new ulong[2]; double* d = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - cmpsd XMM0, XMM1, 0; - mov EAX, c; - movdqu [EAX], XMM0; - mov EAX, d; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + cmpsd XMM0, XMM1, 0; + mov EAX, c; + movdqu [EAX], XMM0; + mov EAX, d; + movupd [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + mov RAX, b; + movupd XMM1, [RAX]; + cmpsd XMM0, XMM1, 0; + mov RAX, c; + movdqu [RAX], XMM0; + mov RAX, d; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0] != ulong.max){
--- a/run/a/asm_cmpsd_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpsd_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,14 +24,28 @@ ulong* c = new ulong[2]; double* d = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - cmpsd XMM0, b, 0; - mov EAX, c; - movdqu [EAX], XMM0; - mov EAX, d; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + cmpsd XMM0, b, 0; + mov EAX, c; + movdqu [EAX], XMM0; + mov EAX, d; + movupd [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + cmpsd XMM0, b, 0; + mov RAX, c; + movdqu [RAX], XMM0; + mov RAX, d; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0] != ulong.max){
--- a/run/a/asm_cmpss_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpss_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -25,15 +25,30 @@ uint* c = new uint[4]; float* f = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - movups XMM1, [EAX]; - cmpss XMM0, XMM1, 0; - mov EAX, c; - movdqu [EAX], XMM0; - mov EAX, f; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + movups XMM1, [EAX]; + cmpss XMM0, XMM1, 0; + mov EAX, c; + movdqu [EAX], XMM0; + mov EAX, f; + movups [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + movups XMM1, [RAX]; + cmpss XMM0, XMM1, 0; + mov RAX, c; + movdqu [RAX], XMM0; + mov RAX, f; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0] != uint.max){
--- a/run/a/asm_cmpss_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpss_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ uint* c = new uint[4]; float* f = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - cmpss XMM0, b, 0; - mov EAX, c; - movdqu [EAX], XMM0; - mov EAX, f; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + cmpss XMM0, b, 0; + mov EAX, c; + movdqu [EAX], XMM0; + mov EAX, f; + movups [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + cmpss XMM0, b, 0; + mov RAX, c; + movdqu [RAX], XMM0; + mov RAX, f; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0] != uint.max){
--- a/run/a/asm_cmpxch8b_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxch8b_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxch8b_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_01_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_01_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_cmpxchg_02_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cmpxchg_02_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_cmpxchg_02_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_comiss_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_comiss_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -28,15 +28,30 @@ b[2] = 4.0f; b[3] = 6.0f; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - comiss XMM0, XMM1; - jnz error; - jp error; - jc error; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + comiss XMM0, XMM1; + jnz error; + jp error; + jc error; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + mov RAX, b; + movups XMM1, [RAX]; + comiss XMM0, XMM1; + jnz error; + jp error; + jc error; + } + }else{ + static assert(0, "unhandled pointer size"); } return 0;
--- a/run/a/asm_cvtdq2pd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtdq2pd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,12 +24,24 @@ double* b = new double[2]; - asm{ - mov EAX, a; - movdqu XMM0, [EAX]; - cvtdq2pd XMM1, XMM0; - mov EAX, b; - movdqu [EAX], XMM1; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movdqu XMM0, [EAX]; + cvtdq2pd XMM1, XMM0; + mov EAX, b; + movdqu [EAX], XMM1; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movdqu XMM0, [RAX]; + cvtdq2pd XMM1, XMM0; + mov RAX, b; + movdqu [RAX], XMM1; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != 0){
--- a/run/a/asm_cvtdq2ps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtdq2ps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,12 +24,24 @@ float* b = new float[4]; - asm{ - mov EAX, a; - movdqu XMM0, [EAX]; - cvtdq2ps XMM1, XMM0; - mov EAX, b; - movdqu [EAX], XMM1; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movdqu XMM0, [EAX]; + cvtdq2ps XMM1, XMM0; + mov EAX, b; + movdqu [EAX], XMM1; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movdqu XMM0, [RAX]; + cvtdq2ps XMM1, XMM0; + mov RAX, b; + movdqu [RAX], XMM1; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != 0.0f){
--- a/run/a/asm_cvtpd2dq_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtpd2dq_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -22,12 +22,24 @@ int* b = new int[4]; - asm{ - mov EAX, a; - movdqu XMM0, [EAX]; - cvtpd2dq XMM1, XMM0; - mov EAX, b; - movdqu [EAX], XMM1; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movdqu XMM0, [EAX]; + cvtpd2dq XMM1, XMM0; + mov EAX, b; + movdqu [EAX], XMM1; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movdqu XMM0, [RAX]; + cvtpd2dq XMM1, XMM0; + mov RAX, b; + movdqu [RAX], XMM1; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != -2){
--- a/run/a/asm_cvtpd2pi_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtpd2pi_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -23,13 +23,26 @@ int* b = new int[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - cvtpd2pi MM0, XMM0; - mov EAX, b; - movq [EAX], MM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + cvtpd2pi MM0, XMM0; + mov EAX, b; + movq [EAX], MM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + cvtpd2pi MM0, XMM0; + mov RAX, b; + movq [RAX], MM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != -2){
--- a/run/a/asm_cvtpi2pd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtpi2pd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -23,13 +23,26 @@ double* b = new double[2]; - asm{ - mov EAX, a; - movq MM0, [EAX]; - cvtpi2pd XMM0, MM0; - mov EAX, b; - movupd [EAX], XMM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movq MM0, [EAX]; + cvtpi2pd XMM0, MM0; + mov EAX, b; + movupd [EAX], XMM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movq MM0, [RAX]; + cvtpi2pd XMM0, MM0; + mov RAX, b; + movupd [RAX], XMM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } b[0] += 3.0;
--- a/run/a/asm_cvtpi2ps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtpi2ps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -29,15 +29,30 @@ float* c = new float[4]; - asm{ - mov EAX, a; - movq MM0, [EAX]; - mov EAX, b; - movups XMM0, [EAX]; - cvtpi2ps XMM0, MM0; - mov EAX, c; - movups [EAX], XMM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movq MM0, [EAX]; + mov EAX, b; + movups XMM0, [EAX]; + cvtpi2ps XMM0, MM0; + mov EAX, c; + movups [EAX], XMM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movq MM0, [RAX]; + mov RAX, b; + movups XMM0, [RAX]; + cvtpi2ps XMM0, MM0; + mov RAX, c; + movups [RAX], XMM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 3.0f;
--- a/run/a/asm_cvtps2pi_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvtps2pi_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -25,13 +25,26 @@ int* b = new int[2]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - cvtps2pi MM0, XMM0; - mov EAX, b; - movq [EAX], MM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + cvtps2pi MM0, XMM0; + mov EAX, b; + movq [EAX], MM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + cvtps2pi MM0, XMM0; + mov RAX, b; + movq [RAX], MM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != 1){
--- a/run/a/asm_cvttpd2pi_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvttpd2pi_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -23,13 +23,26 @@ int* b = new int[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - cvttpd2pi MM0, XMM0; - mov EAX, b; - movq [EAX], MM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + cvttpd2pi MM0, XMM0; + mov EAX, b; + movq [EAX], MM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movupd XMM0, [RAX]; + cvttpd2pi MM0, XMM0; + mov RAX, b; + movq [RAX], MM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != -2){
--- a/run/a/asm_cvttps2pi_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_cvttps2pi_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -25,13 +25,26 @@ int* b = new int[2]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - cvttps2pi MM0, XMM0; - mov EAX, b; - movq [EAX], MM0; - emms; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + cvttps2pi MM0, XMM0; + mov EAX, b; + movq [EAX], MM0; + emms; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movups XMM0, [RAX]; + cvttps2pi MM0, XMM0; + mov RAX, b; + movq [RAX], MM0; + emms; + } + }else{ + static assert(0, "unhandled pointer size"); } if(b[0] != 1){
--- a/run/a/asm_div_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_div_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_div_02_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_div_02_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_div_02_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_div_02_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_div_02_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_div_02_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_div_02_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_divpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_divpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ double* c = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - divpd XMM0, XMM1; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + divpd 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]; + divpd XMM0, XMM1; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 8.0;
--- a/run/a/asm_divps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_divps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -28,14 +28,28 @@ float* c = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - divps XMM0, XMM1; - mov EAX, c; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + divps 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]; + divps XMM0, XMM1; + mov RAX, c; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 8.0f;
--- a/run/a/asm_divsd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_divsd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -24,14 +24,28 @@ double* c = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - divsd XMM0, XMM1; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + divsd 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]; + divsd XMM0, XMM1; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 8.0f;
--- a/run/a/asm_divss_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_divss_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -30,14 +30,28 @@ float* c = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - divss XMM0, XMM1; - mov EAX, c; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + divss 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]; + divss XMM0, XMM1; + mov RAX, c; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 8.0f;
--- a/run/a/asm_ebx_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_ebx_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_ebx_01; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_ebx_02.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_ebx_02.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_ebx_02; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmovb_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmovb_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmovb_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmovbe_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmovbe_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmovbe_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmove_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmove_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmove_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmovnb_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmovnb_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmovnb_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmovnbe_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmovnbe_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmovnbe_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fcmovne_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fcmovne_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_fcmovne_01_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_fnsave_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fnsave_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -16,7 +16,7 @@ int main(){ haveFPU!()(); - static if(size_t.sizeof==4 || size_t.sizeof==6){ + static if(size_t.sizeof==4 || size_t.sizeof==8){ ubyte stateSize = 108; }else static if(size_t.sizeof==2){ ubyte stateSize = 94; @@ -26,9 +26,18 @@ ubyte* state = new ubyte[stateSize]; - asm{ - mov EAX, state; - fnsave [EAX]; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, state; + fnsave [EAX]; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, state; + fnsave [RAX]; + } + }else{ + static assert(0, "unhandled pointer size"); } return 0;
--- a/run/a/asm_fsave_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_fsave_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -16,7 +16,7 @@ int main(){ haveFPU!()(); - static if(size_t.sizeof==4 || size_t.sizeof==6){ + static if(size_t.sizeof==4 || size_t.sizeof==8){ ubyte stateSize = 108; }else static if(size_t.sizeof==2){ ubyte stateSize = 94; @@ -26,9 +26,18 @@ ubyte* state = new ubyte[stateSize]; - asm{ - mov EAX, state; - fsave [EAX]; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, state; + fsave [EAX]; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, state; + fsave [RAX]; + } + }else{ + static assert(0, "unhandled pointer size"); } return 0;
--- a/run/a/asm_haddpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_haddpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ double* c = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - haddpd XMM0, XMM1; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + haddpd 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]; + haddpd XMM0, XMM1; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] -= 18.0;
--- a/run/a/asm_haddps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_haddps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -30,14 +30,28 @@ float* c = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - haddps XMM0, XMM1; - mov EAX, c; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + haddps 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]; + haddps XMM0, XMM1; + mov RAX, c; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] -= 13.3f;
--- a/run/a/asm_hsubpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_hsubpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ double* c = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - hsubpd XMM0, XMM1; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + hsubpd 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]; + hsubpd XMM0, XMM1; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 1.0;
--- a/run/a/asm_hsubps_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_hsubps_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -30,14 +30,28 @@ float* c = new float[4]; - asm{ - mov EAX, a; - movups XMM0, [EAX]; - mov EAX, b; - movups XMM1, [EAX]; - hsubps XMM0, XMM1; - mov EAX, c; - movups [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movups XMM0, [EAX]; + mov EAX, b; + movups XMM1, [EAX]; + hsubps 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]; + hsubps XMM0, XMM1; + mov RAX, c; + movups [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } c[0] += 1.0f;
--- a/run/a/asm_imul_03_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_imul_03_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_imul_03_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_imul_03_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_imul_03_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_imul_03_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_imul_03_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_imul_03_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_imul_03_C; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_imul_04_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_imul_04_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_imul_04_A; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_imul_04_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_imul_04_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,6 +4,8 @@ module dstress.run.a.asm_imul_04_B; +// __DSTRESS_TORTURE_BLOCK__ -fPIC + version(D_InlineAsm_X86){ version = runTest; }else version(D_InlineAsm_X86_64){
--- a/run/a/asm_jae_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jae_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jae_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=6; @@ -17,11 +23,13 @@ save: mov a, EAX; } - assert(a == 6); + if(a != 6){ + assert(0); + } return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jae_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jae_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jae_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=5; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jae_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jae_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jae_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=4; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jb_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jb_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jb_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=6; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jb_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jb_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jb_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=5; @@ -20,8 +26,8 @@ assert(a == 6); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jb_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jb_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jb_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=4; @@ -20,8 +26,8 @@ assert(a == 6); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jbe_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jbe_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jbe_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=6; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jbe_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jbe_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jbe_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=5; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jbe_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jbe_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jbe_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=4; @@ -20,8 +26,8 @@ assert(a == 6); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jc_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jc_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jc_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jc_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jc_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jc_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jczx_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jczx_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jcxz_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jczx_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jczx_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jcxz_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_je_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_je_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_je_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_je_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_je_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_je_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jeczx_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jeczx_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jecxz_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jeczx_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jeczx_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jecxz_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jg_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jg_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jg_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == int.max); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jg_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jg_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jg_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jg_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jg_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jg_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jge_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jge_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -2,10 +2,16 @@ // $Date$ // $Author$ -module dstress.run.a.asm_jge_01_C; +module dstress.run.a.asm_jge_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == int.max); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jge_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jge_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jge_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jge_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jge_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jge_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jl_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jl_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jl_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jl_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jl_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jl_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jl_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jl_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jl_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == int.min); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jle_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jle_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jle_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jle_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jle_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jle_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jle_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jle_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jle_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == int.min); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jna_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jna_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jna_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 2; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jna_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jna_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jna_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 3; @@ -20,8 +26,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jna_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jna_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jna_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 3; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnae_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnae_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnae_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnae_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnae_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnae_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnae_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnae_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnae_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 3; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnb_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnb_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnb_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnb_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnb_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnb_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnb_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnb_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnb_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnbe_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnbe_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnbe_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 3; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnbe_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnbe_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnbe_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnbe_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnbe_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnbe_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnc_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnc_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnc_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnc_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnc_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnc_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jne_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jne_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jne_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 3; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jne_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jne_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jne_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jne_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jne_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jne_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a = 4; uint b = 3; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jng_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jng_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jng_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jng_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jng_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jng_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jng_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jng_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jng_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == int.min); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnge_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnge_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnge_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnge_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnge_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnge_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnge_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnge_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnge_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == int.min); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnl_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnl_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnl_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == int.max); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnl_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnl_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnl_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 4); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnl_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnl_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnl_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = uint.min; int b = uint.max; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnle_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnle_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnle_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.max; int b = int.min; @@ -20,8 +26,8 @@ assert(a == int.max); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnle_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnle_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnle_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = 4; int b = 4; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnle_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnle_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnle_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = int.max; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jno_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jno_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jno_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; int b = 1; @@ -20,8 +26,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jno_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jno_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jno_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min+1; int b = 1; @@ -20,8 +26,8 @@ assert(a == int.min+1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnp_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnp_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnp_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ byte a; asm{ @@ -19,8 +25,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnp_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnp_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnp_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ byte a; asm{ @@ -19,8 +25,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnp_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnp_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnp_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ byte a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnp_01_D.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnp_01_D.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnp_01_D; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ byte a; asm{ @@ -19,8 +25,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jns_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jns_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jns_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jns_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jns_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jns_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a; asm{ @@ -19,8 +25,8 @@ assert(a == 3); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnz_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnz_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnz_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnz_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnz_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnz_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jnz_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jnz_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jnz_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jo_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jo_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jo_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == int.min); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jo_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jo_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jo_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min-1; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jp_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jp_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jp_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 1); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jp_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jp_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jp_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jpe_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jpe_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jpe_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 8); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jpe_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jpe_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jpe_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jpo_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jpo_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jpo_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jpo_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jpo_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jpo_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 8); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_js_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_js_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_js_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 0); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_js_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_js_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_js_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_js_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_js_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_js_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ int a = int.min; asm{ @@ -19,8 +25,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jz_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jz_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jz_01_A; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=5; @@ -20,8 +26,8 @@ assert(a == 5); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jz_01_B.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jz_01_B.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jz_01_B; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=4; @@ -20,8 +26,8 @@ assert(a == 6); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_jz_01_C.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_jz_01_C.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,8 +4,14 @@ module dstress.run.a.asm_jz_01_C; -int main(){ - version(D_InlineAsm){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ uint a=5; uint b=6; @@ -20,8 +26,8 @@ assert(a == 6); return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_lar_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_lar_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,16 +4,22 @@ module dstress.run.a.asm_lar_01; -int main(){ - version(D_InlineAsm_X86){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ asm{ mov AX, 0x0; - lar BX, AX; + lar CX, AX; } return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); }
--- a/run/a/asm_lar_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_lar_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -14,7 +14,7 @@ int main(){ asm{ mov AX, 0x0; - lar BX, AX; + lar CX, AX; } return 0;
--- a/run/a/asm_lddqu_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_lddqu_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -36,11 +36,22 @@ ubyte* b = new ubyte[16]; - asm{ - mov EAX, a; - lddqu XMM0, [EAX]; - mov EAX, b; - movdqu [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + lddqu XMM0, [EAX]; + mov EAX, b; + movdqu [EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + lddqu XMM0, [RAX]; + mov RAX, b; + movdqu [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } for(size_t i = 0; i < 16; i++){
--- a/run/a/asm_maxpd_01_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_maxpd_01_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -26,14 +26,28 @@ double* c = new double[2]; - asm{ - mov EAX, a; - movupd XMM0, [EAX]; - mov EAX, b; - movupd XMM1, [EAX]; - maxpd XMM0, XMM1; - mov EAX, c; - movupd [EAX], XMM0; + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movupd XMM0, [EAX]; + mov EAX, b; + movupd XMM1, [EAX]; + maxpd 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]; + maxpd XMM0, XMM1; + mov RAX, c; + movupd [RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); } if(c[0] != 2.0){
--- a/run/a/asm_movd_02_A.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_movd_02_A.d Mon Sep 25 11:38:19 2006 +0000 @@ -8,8 +8,14 @@ module dstress.run.a.asm_movd_02_A; -int main(){ - version(D_InlineAsm_X86){ +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; +} + +version(runTest){ + int main(){ ulong l = 0x4444_AAAA_CCCC_1111; uint i = 0x33FF_FF33; asm{ @@ -32,8 +38,8 @@ return 0; bug: assert(0); - }else{ - pragma(msg, "no X86 inline asm support"); - return 0; } +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); }
--- a/run/a/asm_movdqa_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_movdqa_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,33 +4,58 @@ module dstress.run.a.asm_movdqa_01; -align(16) struct X{ - ulong[2] c; +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; } -int main(){ - version(D_InlineAsm){ - X* a = new X; +version(runTest){ + align(16) struct X{ + ulong[2] c; + } + + int main(){ + X* a = new X(); a.c[0]=1; a.c[1]=2; - X* b = new X; - - assert(a.c[0]!=b.c[0]); - assert(a.c[1]!=b.c[1]); + X* b = new X(); - asm{ - mov EAX, a; - mov EBX, b; - movdqa XMM0, X.c[EAX]; - movdqa X.c[EBX], XMM0; + if(a.c[0] == b.c[0]){ + assert(0); + } + if(a.c[1] == b.c[1]){ + assert(0); } - assert(a.c[0]==b.c[0]); - assert(a.c[1]==b.c[1]); + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movdqa XMM0, X.c[EAX]; + mov EAX, b; + movdqa X.c[EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movdqa XMM0, X.c[RAX]; + mov RAX, b; + movdqa X.c[RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); + } + + if(a.c[0] != b.c[0]){ + assert(0); + } + if(a.c[1] != b.c[1]){ + assert(0); + } return 0; - }else{ - pragma(msg, "no Inline asm support"); - static assert(0); } -} \ No newline at end of file +}else{ + pragma(msg, "DSTRESS{XFAIL}: no inline ASM support"); + static assert(0); +}
--- a/run/a/asm_movdqu_01.d Thu Sep 21 23:57:44 2006 +0000 +++ b/run/a/asm_movdqu_01.d Mon Sep 25 11:38:19 2006 +0000 @@ -4,34 +4,59 @@ module dstress.run.a.asm_movdqu_01; -align(3) struct X{ - byte dummy; - ulong[2] c; +version(D_InlineAsm_X86){ + version = runTest; +}else version(D_InlineAsm_X86_64){ + version = runTest; } -int main(){ - version(D_InlineAsm){ - X* a = new X; +version(runTest){ + align(3) struct X{ + byte dummy; + ulong[2] c; + } + + int main(){ + X* a = new X(); a.c[0]=1; a.c[1]=2; - X* b = new X; - - assert(a.c[0]!=b.c[0]); - assert(a.c[1]!=b.c[1]); + X* b = new X(); - asm{ - mov EAX, a; - mov EBX, b; - movdqu XMM0, X.c[EAX]; - movdqu X.c[EBX], XMM0; + if(a.c[0] == b.c[0]){ + assert(0); + } + if(a.c[1] == b.c[1]){ + assert(0); } - assert(a.c[0]==b.c[0]); - assert(a.c[1]==b.c[1]); + static if(size_t.sizeof == 4){ + asm{ + mov EAX, a; + movdqu XMM0, X.c[EAX]; + mov EAX, b; + movdqu X.c[EAX], XMM0; + } + }else static if(size_t.sizeof == 8){ + asm{ + mov RAX, a; + movdqu XMM0, X.c[RAX]; + mov RAX, b; + movdqu X.c[RAX], XMM0; + } + }else{ + static assert(0, "unhandled pointer size"); + } + + if(a.c[0] != b.c[0]){ + assert(0); + } + if(a.c[1] != b.c[1]){ + 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); +}