diff --git a/src/misc/pv/byteBuffer.h b/src/misc/pv/byteBuffer.h
index c87e0d976..0c9831e17 100644
--- a/src/misc/pv/byteBuffer.h
+++ b/src/misc/pv/byteBuffer.h
@@ -700,7 +700,7 @@ private:
             value = swap<T>(value);
 
         //assert(is_aligned(_position, sizeof(T)));
-        *((T*)_position) = value;
+        memcpy( _position, &value, sizeof(value) );
         _position += sizeof(T);
     }
 
@@ -712,8 +712,8 @@ private:
         if(reverse<T>())
             value = swap<T>(value);
 
-        //assert(is_aligned(_buffer+index, sizeof(T))); //TODO: special case for targets which support unaligned access
-        *((T*)(_buffer+index)) = value;
+        //assert(is_aligned(_buffer+index, sizeof(T)));
+        memcpy(_buffer+index, &value, sizeof(value));
     }
 
 #if defined (__GNUC__) && (__GNUC__ < 3)
@@ -727,7 +727,8 @@ private:
         assert(sizeof(T)<=getRemaining());
 
         //assert(is_aligned(_position, sizeof(T)));
-        T value = *((T*)_position);
+        T value;
+        memcpy( &value, _position, sizeof(value) );
         _position += sizeof(T);
 
         if(reverse<T>())
@@ -741,7 +742,8 @@ private:
         assert(_buffer+index<=_limit);
 
         //assert(is_aligned(_position, sizeof(T)));
-        T value = *((T*)(_buffer + index));
+        T value;
+        memcpy( &value, _buffer + index, sizeof(value) );
 
         if(reverse<T>())
             value = swap<T>(value);
@@ -753,17 +755,19 @@ private:
     {
         // we require aligned arrays...
         //assert(is_aligned(_position, sizeof(T)));
-        T* start = (T*)_position;
         size_t n = sizeof(T)*count; // bytes
         assert(n<=getRemaining());
 
         if (reverse<T>()) {
-            for(std::size_t i=0; i<count; i++)
-                start[i] = swap<T>(values[i]);
+            for(std::size_t i=0; i<count; i++) {
+                T sv = swap<T>(values[i]);
+                memcpy(_position, &sv, sizeof(sv));
+                _position += sizeof(T);
+            }
         } else {
-            memcpy(start, values, n);
+            memcpy(_position, values, n);
+            _position += n;
         }
-        _position += n;
     }
 
     template<typename T>
@@ -771,17 +775,17 @@ private:
     {
         // we require aligned arrays...
         //assert(is_aligned(_position, sizeof(T)));
-        const T* start = (T*)_position;
         size_t n = sizeof(T)*count; // bytes
         assert(n<=getRemaining());
 
+        memcpy(values, _position, n);
+        _position += n;
+
         if (reverse<T>()) {
-            for(std::size_t i=0; i<count; i++)
-                values[i] = swap<T>(start[i]);
-        } else {
-            memcpy(values, start, n);
+            for(std::size_t i=0; i<count; i++) {
+                values[i] = swap<T>(values[i]);
+			}
         }
-        _position += n;
     }
 
 }}