diff --git a/include/etl/atomic/atomic_gcc_sync.h b/include/etl/atomic/atomic_gcc_sync.h
index 091540d6..de19f443 100644
--- a/include/etl/atomic/atomic_gcc_sync.h
+++ b/include/etl/atomic/atomic_gcc_sync.h
@@ -61,6 +61,9 @@ namespace etl
     memory_order_seq_cst
   } memory_order;
 
+  //***************************************************************************
+  /// For all types except pointers
+  //***************************************************************************
   template <typename T>
   class atomic
   {
@@ -436,18 +439,21 @@ namespace etl
     mutable volatile T value;
   };
 
+  //***************************************************************************
+  /// Specialisation for pointers
+  //***************************************************************************
   template <typename T>
   class atomic<T*>
   {
   public:
 
     atomic()
-      : value(ETL_NULLPTR)
+      : value(0U)
     {
     }
 
     atomic(T* v)
-      : value(v)
+      : value(uintptr_t(v))
     {
     }
 
@@ -469,7 +475,7 @@ namespace etl
     // Pre-increment
     T* operator ++()
     {
-      return (T*)__sync_add_and_fetch(&(volatile void*)value, sizeof(T));
+      return (T*)__sync_add_and_fetch(&value, sizeof(T));
     }
 
     T* operator ++() volatile
@@ -540,7 +546,7 @@ namespace etl
 
     operator T*() volatile const
     {
-      return __sync_fetch_and_add(&value, 0);
+      return (T*)__sync_fetch_and_add(&value, 0);
     }
 
     // Is lock free?
@@ -557,12 +563,12 @@ namespace etl
     // Store
     void store(T* v, etl::memory_order order = etl::memory_order_seq_cst)
     {
-      __sync_lock_test_and_set(&value, v);
+      __sync_lock_test_and_set(&value, uintptr_t(v));
     }
 
     void store(T* v, etl::memory_order order = etl::memory_order_seq_cst) volatile
     {
-      __sync_lock_test_and_set(&value, v);
+      __sync_lock_test_and_set(&value, uintptr_t(v));
     }
 
     // Load
@@ -612,7 +618,7 @@ namespace etl
     // Compare exchange weak
     bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst)
     {
-      T* old = __sync_val_compare_and_swap(&value, expected, desired);
+      T* old = (T*)__sync_val_compare_and_swap(&value, uintptr_t(expected), uintptr_t(desired));
 
       if (old == expected)
       {
@@ -627,7 +633,7 @@ namespace etl
 
     bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order order = etl::memory_order_seq_cst) volatile
     {
-      T* old = __sync_val_compare_and_swap(&value, expected, desired);
+      T* old = (T*)__sync_val_compare_and_swap(&value, uintptr_t(expected), uintptr_t(desired));
 
       if (old == expected)
       {
@@ -642,7 +648,7 @@ namespace etl
 
     bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure)
     {
-      T* old = __sync_val_compare_and_swap(&value, expected, desired);
+      T* old = (T*)__sync_val_compare_and_swap(&value, uintptr_t(expected), uintptr_t(desired));
 
       if (old == expected)
       {
@@ -657,7 +663,7 @@ namespace etl
 
     bool compare_exchange_weak(T*& expected, T* desired, etl::memory_order success, etl::memory_order failure) volatile
     {
-      T* old = __sync_val_compare_and_swap(&value, expected, desired);
+      T* old = (T*)__sync_val_compare_and_swap(&value, uintptr_t(expected), uintptr_t(desired));
 
       if (old == expected)
       {
@@ -740,7 +746,7 @@ namespace etl
     atomic& operator =(const atomic&);
     atomic& operator =(const atomic&) volatile;
 
-    mutable volatile T* value;
+    mutable volatile uintptr_t value;
   };
 
   typedef etl::atomic<char>                atomic_char;