Whitespace change in asm intrinsics

15 files changed, 25 insertions, 25 deletions

diff --git a/vec_altivec_float4.h b/vec_altivec_float4.h
index c5eb28b..9c52734 100644
--- a/vec_altivec_float4.h
+++ b/vec_altivec_float4.h
@@ -233,7 +233,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<Altivec:4*float>"; }
-    void barrier() { __asm__("": "+v" (v)); }
+    void barrier() { __asm__("": "+v"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_avx_double4.h b/vec_avx_double4.h
index 9ed8739..3d3225c 100644
--- a/vec_avx_double4.h
+++ b/vec_avx_double4.h
@@ -356,7 +356,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<AVX:4*double>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_avx_float8.h b/vec_avx_float8.h
index 1e50425..fe5273f 100644
--- a/vec_avx_float8.h
+++ b/vec_avx_float8.h
@@ -342,7 +342,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<AVX:8*float>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_avx_fp16_16.h b/vec_avx_fp16_16.h
index 7cb98b2..d2e39a9 100644
--- a/vec_avx_fp16_16.h
+++ b/vec_avx_fp16_16.h
@@ -352,7 +352,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<AVX:16*fp16>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_avx_fp8_32.h b/vec_avx_fp8_32.h
index a6e33a1..972a716 100644
--- a/vec_avx_fp8_32.h
+++ b/vec_avx_fp8_32.h
@@ -402,7 +402,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<AVX:32*fp8>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_neon_float2.h b/vec_neon_float2.h
index ba14d86..a27bb15 100644
--- a/vec_neon_float2.h
+++ b/vec_neon_float2.h
@@ -245,7 +245,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<NEON:2*float>"; }
-    void barrier() { __asm__("": "+w" (v)); }
+    void barrier() { __asm__("": "+w"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_neon_float4.h b/vec_neon_float4.h
index 2951420..4e82452 100644
--- a/vec_neon_float4.h
+++ b/vec_neon_float4.h
@@ -251,7 +251,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<NEON:4*float>"; }
-    void barrier() { __asm__("": "+w" (v)); }
+    void barrier() { __asm__("": "+w"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_pseudo.h b/vec_pseudo.h
index 29f2ed0..98948b2 100644
--- a/vec_pseudo.h
+++ b/vec_pseudo.h
@@ -429,24 +429,24 @@ namespace vecmathlib {
 #if defined __GNUC__ && !defined __clang__ && !defined __ICC
       // GCC crashes when +X is used as constraint
 #  if defined __SSE2__
-      for (int d=0; d<size; ++d) __asm__("": "+x" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+x"(v[d]));
 #  elif defined __PPC64__       // maybe also __PPC__
-      for (int d=0; d<size; ++d) __asm__("": "+f" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+f"(v[d]));
 #  elif defined __arm__
-      for (int d=0; d<size; ++d) __asm__("": "+w" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+w"(v[d]));
 #  else
 #    error "Floating point barrier undefined on this architecture"
 #  endif
 #elif defined __clang__
-      for (int d=0; d<size; ++d) __asm__("": "+X" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+X"(v[d]));
 #elif defined __ICC
       for (int d=0; d<size; ++d) {
         real_t tmp = v[d];
-        __asm__("": "+X" (tmp));
+        __asm__("": "+X"(tmp));
         v[d] = tmp;
       }
 #elif defined __IBMCPP__
-      for (int d=0; d<size; ++d) __asm__("": "+f" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+f"(v[d]));
 #else
 #  error "Floating point barrier undefined on this architecture"
 #endif
diff --git a/vec_qpx_double4.h b/vec_qpx_double4.h
index 46cd1d0..6d05a17 100644
--- a/vec_qpx_double4.h
+++ b/vec_qpx_double4.h
@@ -346,7 +346,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<QPX:4*double>"; }
-    void barrier() { __asm__("": "+v" (v)); }
+    void barrier() { __asm__("": "+v"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_sse_double1.h b/vec_sse_double1.h
index 989478e..b05168f 100644
--- a/vec_sse_double1.h
+++ b/vec_sse_double1.h
@@ -222,7 +222,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<SSE2:1*double>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_sse_double2.h b/vec_sse_double2.h
index 47586cb..4d98dbc 100644
--- a/vec_sse_double2.h
+++ b/vec_sse_double2.h
@@ -328,7 +328,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<SSE2:2*double>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_sse_float1.h b/vec_sse_float1.h
index 83d882b..6aa42dc 100644
--- a/vec_sse_float1.h
+++ b/vec_sse_float1.h
@@ -225,7 +225,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<SSE2:1*float>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_sse_float4.h b/vec_sse_float4.h
index 366c7bb..2f1be19 100644
--- a/vec_sse_float4.h
+++ b/vec_sse_float4.h
@@ -314,7 +314,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<SSE2:4*float>"; }
-    void barrier() { __asm__("": "+x" (v)); }
+    void barrier() { __asm__("": "+x"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");
diff --git a/vec_test.h b/vec_test.h
index 2d05b67..88165db 100644
--- a/vec_test.h
+++ b/vec_test.h
@@ -423,24 +423,24 @@ namespace vecmathlib {
 #if defined __GNUC__ && !defined __clang__ && !defined __ICC
       // GCC crashes when +X is used as constraint
 #  if defined __SSE2__
-      for (int d=0; d<size; ++d) __asm__("": "+x" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+x"(v[d]));
 #  elif defined __PPC64__       // maybe also __PPC__
-      for (int d=0; d<size; ++d) __asm__("": "+f" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+f"(v[d]));
 #  elif defined __arm__
-      for (int d=0; d<size; ++d) __asm__("": "+w" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+w"(v[d]));
 #  else
 #    error "Floating point barrier undefined on this architecture"
 #  endif
 #elif defined __clang__
-      for (int d=0; d<size; ++d) __asm__("": "+X" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+X"(v[d]));
 #elif defined __ICC
       for (int d=0; d<size; ++d) {
         real_t tmp = v[d];
-        __asm__("": "+X" (tmp));
+        __asm__("": "+X"(tmp));
         v[d] = tmp;
       }
 #elif defined __IBMCPP__
-      for (int d=0; d<size; ++d) __asm__("": "+f" (v[d]));
+      for (int d=0; d<size; ++d) __asm__("": "+f"(v[d]));
 #else
 #  error "Floating point barrier undefined on this architecture"
 #endif
diff --git a/vec_vsx_double2.h b/vec_vsx_double2.h
index 562969a..4b8c57c 100644
--- a/vec_vsx_double2.h
+++ b/vec_vsx_double2.h
@@ -366,7 +366,7 @@ namespace vecmathlib {
     static int const alignment = sizeof(vector_t);
     
     static char const* name() { return "<VSX:2*double>"; }
-    void barrier() { __asm__("": "+v" (v)); }
+    void barrier() { __asm__("": "+v"(v)); }
     
     static_assert(size * sizeof(real_t) == sizeof(vector_t),
                   "vector size is wrong");