diff --git a/src/sim/serialize.hh b/src/sim/serialize.hh
index adaefdd..5434777 100644
--- a/src/sim/serialize.hh
+++ b/src/sim/serialize.hh
@@ -285,6 +285,29 @@
     os << value;
 }
 
+template <class T>
+bool
+parseParam(const std::string &s, BitUnionType<T> &value)
+{
+    auto storage = static_cast<BitUnionBaseType<T>>(value);
+    auto res = to_number(s, storage);
+    value = storage;
+    return res;
+}
+
+template <class T>
+void
+showParam(CheckpointOut &os, const BitUnionType<T> &value)
+{
+    auto storage = static_cast<BitUnionBaseType<T>>(value);
+
+    // For a BitUnion8, the storage type is an unsigned char.
+    // Since we want to serialize a number we need to cast to
+    // unsigned int
+    os << ((sizeof(storage) == 1) ?
+        static_cast<unsigned int>(storage) : storage);
+}
+
 // Treat 8-bit ints (chars) as ints on output, not as chars
 template <>
 inline void
@@ -354,13 +377,6 @@
     os << "\n";
 }
 
-template <typename T>
-void
-paramOut(CheckpointOut &cp, const std::string &name, const BitUnionType<T> &p)
-{
-    paramOut(cp, name, static_cast<BitUnionBaseType<T> >(p));
-}
-
 template <class T>
 void
 paramIn(CheckpointIn &cp, const std::string &name, T &param)
@@ -372,15 +388,6 @@
     }
 }
 
-template <typename T>
-void
-paramIn(CheckpointIn &cp, const std::string &name, BitUnionType<T> &p)
-{
-    BitUnionBaseType<T> b;
-    paramIn(cp, name, b);
-    p = b;
-}
-
 template <class T>
 bool
 optParamIn(CheckpointIn &cp, const std::string &name,
@@ -397,20 +404,6 @@
     }
 }
 
-template <typename T>
-bool
-optParamIn(CheckpointIn &cp, const std::string &name,
-           BitUnionType<T> &p, bool warn = true)
-{
-    BitUnionBaseType<T> b;
-    if (optParamIn(cp, name, b, warn)) {
-        p = b;
-        return true;
-    } else {
-        return false;
-    }
-}
-
 template <class T>
 void
 arrayParamOut(CheckpointOut &os, const std::string &name,
@@ -628,31 +621,6 @@
     }
 }
 
-template <class T>
-static void
-arrayParamOut(CheckpointOut &cp, const std::string &name,
-              const BitUnionType<T> *param, unsigned size)
-{
-    // We copy the array into a vector. This is needed since we cannot
-    // directly typecast a pointer to BitUnionType<T> into a pointer
-    // of BitUnionBaseType<T> but we can typecast BitUnionType<T>
-    // to BitUnionBaseType<T> since we overloaded the typecast operator
-    std::vector<BitUnionBaseType<T>> bitunion_vec(param, param + size);
-
-    arrayParamOut(cp, name, bitunion_vec);
-}
-
-template <class T>
-static void
-arrayParamIn(CheckpointIn &cp, const std::string &name,
-             BitUnionType<T> *param, unsigned size)
-{
-    std::vector<BitUnionBaseType<T>> bitunion_vec(size);
-
-    arrayParamIn(cp, name, bitunion_vec);
-    std::copy(bitunion_vec.begin(), bitunion_vec.end(), param);
-}
-
 void
 debug_serialize(const std::string &cpt_dir);