Apply format changes from #2048 (#2059)

Mass change to apply clang-format to everything. We are applying this in a PR by me so the (git) blame is all mine ;) but @aheejin did all the work to get clang-format set up and all the manual work to tidy up some things to make the output nicer in #2048

26 files changed, 411 insertions, 370 deletions

diff --git a/src/support/alloc.h b/src/support/alloc.h
index 075896694..d85cbb0f7 100644
--- a/src/support/alloc.h
+++ b/src/support/alloc.h
@@ -35,10 +35,11 @@ inline void* aligned_malloc(size_t align, size_t size) {
 #if defined(WIN32) || defined(_WIN32)
   _set_errno(0);
   void* ret = _aligned_malloc(size, align);
-  if (errno == ENOMEM) ret = nullptr;
+  if (errno == ENOMEM)
+    ret = nullptr;
   return ret;
 #elif defined(__APPLE__)
-  void *ptr;
+  void* ptr;
   int result = posix_memalign(&ptr, align, size);
   return result == 0 ? ptr : nullptr;
 #else
@@ -56,4 +57,4 @@ inline void aligned_free(void* ptr) {
 
 } // namespace wasm
 
-#endif  // wasm_support_alloc_h
+#endif // wasm_support_alloc_h
diff --git a/src/support/archive.cpp b/src/support/archive.cpp
index b9ca827e4..66f9c192a 100644
--- a/src/support/archive.cpp
+++ b/src/support/archive.cpp
@@ -16,19 +16,19 @@
 
 #include "support/archive.h"
 
-#include <cstring>
 #include "support/utilities.h"
+#include <cstring>
 
 static const char* const magic = "!<arch>\n";
 
 class ArchiveMemberHeader {
- public:
+public:
   uint8_t fileName[16];
   uint8_t timestamp[12];
   uint8_t UID[6];
   uint8_t GID[6];
   uint8_t accessMode[8];
-  uint8_t size[10];  // Size of data only, not including padding or header
+  uint8_t size[10]; // Size of data only, not including padding or header
   uint8_t magic[2];
 
   std::string getName() const;
@@ -42,11 +42,12 @@ std::string ArchiveMemberHeader::getName() const {
     // Special name (string table or reference, or symbol table)
     endChar = ' ';
   } else {
-    endChar = '/';  // regular name
+    endChar = '/'; // regular name
   }
   auto* end =
-      static_cast<const uint8_t*>(memchr(fileName, endChar, sizeof(fileName)));
-  if (!end) end = fileName + sizeof(fileName);
+    static_cast<const uint8_t*>(memchr(fileName, endChar, sizeof(fileName)));
+  if (!end)
+    end = fileName + sizeof(fileName);
   return std::string((char*)(fileName), end - fileName);
 }
 
@@ -60,7 +61,9 @@ uint32_t ArchiveMemberHeader::getSize() const {
   return static_cast<uint32_t>(sizeInt);
 }
 
-Archive::Archive(Buffer& b, bool& error) : data(b), symbolTable({nullptr, 0}), stringTable({nullptr, 0}), firstRegularData(nullptr) {
+Archive::Archive(Buffer& b, bool& error)
+  : data(b), symbolTable({nullptr, 0}), stringTable({nullptr, 0}),
+    firstRegularData(nullptr) {
   error = false;
   if (data.size() < strlen(magic) ||
       memcmp(data.data(), magic, strlen(magic))) {
@@ -78,14 +81,16 @@ Archive::Archive(Buffer& b, bool& error) : data(b), symbolTable({nullptr, 0}), s
     return;
   }
   child_iterator end = child_end();
-  if (it == end) return;  // Empty archive.
+  if (it == end)
+    return; // Empty archive.
 
   const Child* c = &*it;
 
   auto increment = [&]() {
     ++it;
     error = it.hasError();
-    if (error) return true;
+    if (error)
+      return true;
     c = &*it;
     return false;
   };
@@ -93,13 +98,15 @@ Archive::Archive(Buffer& b, bool& error) : data(b), symbolTable({nullptr, 0}), s
   std::string name = c->getRawName();
   if (name == "/") {
     symbolTable = c->getBuffer();
-    if (increment() || it == end) return;
+    if (increment() || it == end)
+      return;
     name = c->getRawName();
   }
 
   if (name == "//") {
     stringTable = c->getBuffer();
-    if (increment() || it == end) return;
+    if (increment() || it == end)
+      return;
     setFirstRegular(*c);
     return;
   }
@@ -112,8 +119,9 @@ Archive::Archive(Buffer& b, bool& error) : data(b), symbolTable({nullptr, 0}), s
 }
 
 Archive::Child::Child(const Archive* parent, const uint8_t* data, bool* error)
-    : parent(parent), data(data) {
-  if (!data) return;
+  : parent(parent), data(data) {
+  if (!data)
+    return;
   len = sizeof(ArchiveMemberHeader) + getHeader()->getSize();
   startOfFile = sizeof(ArchiveMemberHeader);
 }
@@ -129,8 +137,10 @@ std::string Archive::Child::getRawName() const {
 }
 
 Archive::Child Archive::Child::getNext(bool& error) const {
-  uint32_t nextOffset = len + (len & 1); // Members are aligned to even byte boundaries.
-  if ((size_t)(data - (const uint8_t*)parent->data.data() + nextOffset) >= parent->data.size()) {  // End of the archive.
+  // Members are aligned to even byte boundaries.
+  uint32_t nextOffset = len + (len & 1);
+  if ((size_t)(data - (const uint8_t*)parent->data.data() + nextOffset) >=
+      parent->data.size()) { // End of the archive.
     return Child();
   }
   return Child(parent, data + nextOffset, &error);
@@ -140,10 +150,10 @@ std::string Archive::Child::getName() const {
   std::string name = getRawName();
   // Check if it's a special name.
   if (name[0] == '/') {
-    if (name.size() == 1) {  // Linker member.
+    if (name.size() == 1) { // Linker member.
       return name;
     }
-    if (name.size() == 2 && name[1] == '/') {  // String table.
+    if (name.size() == 2 && name[1] == '/') { // String table.
       return name;
     }
     // It's a long name.
@@ -170,7 +180,8 @@ std::string Archive::Child::getName() const {
 }
 
 Archive::child_iterator Archive::child_begin(bool SkipInternal) const {
-  if (data.size() == 0) return child_end();
+  if (data.size() == 0)
+    return child_end();
 
   if (SkipInternal) {
     child_iterator it;
@@ -197,7 +208,7 @@ struct Symbol {
     ++symbolIndex;
   }
 };
-}
+} // namespace
 
 static uint32_t read32be(const uint8_t* buf) {
   return static_cast<uint32_t>(buf[0]) << 24 |
@@ -206,15 +217,20 @@ static uint32_t read32be(const uint8_t* buf) {
 }
 
 void Archive::dump() const {
-  printf("Archive data %p len %zu, firstRegularData %p\n", data.data(),
-         data.size(), firstRegularData);
+  printf("Archive data %p len %zu, firstRegularData %p\n",
+         data.data(),
+         data.size(),
+         firstRegularData);
   printf("Symbol table %p, len %u\n", symbolTable.data, symbolTable.len);
   printf("string table %p, len %u\n", stringTable.data, stringTable.len);
   const uint8_t* buf = symbolTable.data;
   if (!buf) {
     for (auto c = child_begin(), e = child_end(); c != e; ++c) {
-      printf("Child %p, len %u, name %s, size %u\n", c->data, c->len,
-             c->getName().c_str(), c->getSize());
+      printf("Child %p, len %u, name %s, size %u\n",
+             c->data,
+             c->len,
+             c->getName().c_str(),
+             c->getSize());
     }
     return;
   }
diff --git a/src/support/archive.h b/src/support/archive.h
index 0ca066ff1..cba7c4fc1 100644
--- a/src/support/archive.h
+++ b/src/support/archive.h
@@ -38,7 +38,7 @@ class Archive {
   // because most things in these buffers are not nul-terminated
   using Buffer = std::vector<char>;
 
- public:
+public:
   struct SubBuffer {
     const uint8_t* data;
     uint32_t len;
@@ -56,7 +56,7 @@ class Archive {
     }
     Child getNext(bool& error) const;
 
-   public:
+  public:
     Child(){};
     Child(const Archive* parent, const uint8_t* data, bool* error);
     // Size of actual member data (no header/padding)
@@ -69,8 +69,8 @@ class Archive {
   class child_iterator {
     friend class Archive;
     Child child;
-    bool error = false;  // TODO: use std::error_code instead?
-   public:
+    bool error = false; // TODO: use std::error_code instead?
+  public:
     child_iterator() = default;
     explicit child_iterator(bool error) : error(error) {}
     child_iterator(const Child& c) : child(c) {}
@@ -94,7 +94,7 @@ class Archive {
   child_iterator child_end() const;
   void dump() const;
 
- private:
+private:
   void setFirstRegular(const Child& c) { firstRegularData = c.data; }
   Buffer& data;
   SubBuffer symbolTable;
@@ -102,4 +102,4 @@ class Archive {
   const uint8_t* firstRegularData;
 };
 
-#endif  // wasm_support_archive_h
+#endif // wasm_support_archive_h
diff --git a/src/support/base64.h b/src/support/base64.h
index 0c87c37c1..8634246a6 100644
--- a/src/support/base64.h
+++ b/src/support/base64.h
@@ -21,20 +21,18 @@
 #include <string>
 #include <vector>
 
-inline std::string base64Encode(std::vector<char> &data) {
+inline std::string base64Encode(std::vector<char>& data) {
   std::string ret;
   size_t i = 0;
 
-  const char* alphabet =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "abcdefghijklmnopqrstuvwxyz"
-    "0123456789+/";
+  const char* alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                         "abcdefghijklmnopqrstuvwxyz"
+                         "0123456789+/";
 
   while (i + 3 <= data.size()) {
-    uint32_t bits =
-      (((uint32_t)(uint8_t) data[i + 0]) << 16) |
-      (((uint32_t)(uint8_t) data[i + 1]) << 8) |
-      (((uint32_t)(uint8_t) data[i + 2]) << 0);
+    uint32_t bits = (((uint32_t)(uint8_t)data[i + 0]) << 16) |
+                    (((uint32_t)(uint8_t)data[i + 1]) << 8) |
+                    (((uint32_t)(uint8_t)data[i + 2]) << 0);
     ret += alphabet[(bits >> 18) & 0x3f];
     ret += alphabet[(bits >> 12) & 0x3f];
     ret += alphabet[(bits >> 6) & 0x3f];
@@ -43,15 +41,14 @@ inline std::string base64Encode(std::vector<char> &data) {
   }
 
   if (i + 2 == data.size()) {
-    uint32_t bits =
-      (((uint32_t)(uint8_t) data[i + 0]) << 8) |
-      (((uint32_t)(uint8_t) data[i + 1]) << 0);
+    uint32_t bits = (((uint32_t)(uint8_t)data[i + 0]) << 8) |
+                    (((uint32_t)(uint8_t)data[i + 1]) << 0);
     ret += alphabet[(bits >> 10) & 0x3f];
     ret += alphabet[(bits >> 4) & 0x3f];
     ret += alphabet[(bits << 2) & 0x3f];
     ret += '=';
   } else if (i + 1 == data.size()) {
-    uint32_t bits = (uint32_t)(uint8_t) data[i + 0];
+    uint32_t bits = (uint32_t)(uint8_t)data[i + 0];
     ret += alphabet[(bits >> 2) & 0x3f];
     ret += alphabet[(bits << 4) & 0x3f];
     ret += '=';
diff --git a/src/support/bits.cpp b/src/support/bits.cpp
index 8f28a7fdb..c237807ee 100644
--- a/src/support/bits.cpp
+++ b/src/support/bits.cpp
@@ -15,28 +15,24 @@
  */
 
 #define wasm_support_bits_definitions
-#include "../compiler-support.h"
 #include "support/bits.h"
+#include "../compiler-support.h"
 
 namespace wasm {
 
-template<>
-int PopCount<uint8_t>(uint8_t v) {
+template<> int PopCount<uint8_t>(uint8_t v) {
   // Small table lookup.
-  static const uint8_t tbl[32] = {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
-    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5
-  };
+  static const uint8_t tbl[32] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2,
+                                  3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,
+                                  3, 4, 2, 3, 3, 4, 3, 4, 4, 5};
   return tbl[v & 0xf] + tbl[v >> 4];
 }
 
-template<>
-int PopCount<uint16_t>(uint16_t v) {
+template<> int PopCount<uint16_t>(uint16_t v) {
   return PopCount((uint8_t)(v & 0xff)) + PopCount((uint8_t)(v >> 8));
 }
 
-template<>
-int PopCount<uint32_t>(uint32_t v) {
+template<> int PopCount<uint32_t>(uint32_t v) {
   // See Stanford bithacks, counting bits set in parallel, "best method":
   // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
   v = v - ((v >> 1) & 0x55555555);
@@ -44,13 +40,11 @@ int PopCount<uint32_t>(uint32_t v) {
   return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
 }
 
-template<>
-int PopCount<uint64_t>(uint64_t v) {
+template<> int PopCount<uint64_t>(uint64_t v) {
   return PopCount((uint32_t)v) + PopCount((uint32_t)(v >> 32));
 }
 
-template<>
-uint32_t BitReverse<uint32_t>(uint32_t v) {
+template<> uint32_t BitReverse<uint32_t>(uint32_t v) {
   // See Hacker's Delight, first edition, figure 7-1.
   v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
   v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
@@ -59,33 +53,28 @@ uint32_t BitReverse<uint32_t>(uint32_t v) {
   return v;
 }
 
-template<>
-int CountTrailingZeroes<uint32_t>(uint32_t v) {
+template<> int CountTrailingZeroes<uint32_t>(uint32_t v) {
   // See Stanford bithacks, count the consecutive zero bits (trailing) on the
   // right with multiply and lookup:
   // http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightMultLookup
-  static const uint8_t tbl[32] = {
-    0,   1, 28,  2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17,  4, 8,
-    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18,  6, 11,  5, 10, 9
-  };
+  static const uint8_t tbl[32] = {0,  1,  28, 2,  29, 14, 24, 3,  30, 22, 20,
+                                  15, 25, 17, 4,  8,  31, 27, 13, 23, 21, 19,
+                                  16, 7,  26, 12, 18, 6,  11, 5,  10, 9};
   return v ? (int)tbl[((uint32_t)((v & -v) * 0x077CB531U)) >> 27] : 32;
 }
 
-template<>
-int CountTrailingZeroes<uint64_t>(uint64_t v) {
+template<> int CountTrailingZeroes<uint64_t>(uint64_t v) {
   return (uint32_t)v ? CountTrailingZeroes((uint32_t)v)
                      : 32 + CountTrailingZeroes((uint32_t)(v >> 32));
 }
 
-template<>
-int CountLeadingZeroes<uint32_t>(uint32_t v) {
+template<> int CountLeadingZeroes<uint32_t>(uint32_t v) {
   // See Stanford bithacks, find the log base 2 of an N-bit integer in
   // O(lg(N)) operations with multiply and lookup:
   // http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
-  static const uint8_t tbl[32] = {
-    31, 22, 30, 21, 18, 10, 29,  2, 20, 17, 15, 13, 9,  6, 28, 1,
-    23, 19, 11,  3, 16, 14,  7, 24, 12,  4,  8, 25, 5, 26, 27, 0
-  };
+  static const uint8_t tbl[32] = {31, 22, 30, 21, 18, 10, 29, 2,  20, 17, 15,
+                                  13, 9,  6,  28, 1,  23, 19, 11, 3,  16, 14,
+                                  7,  24, 12, 4,  8,  25, 5,  26, 27, 0};
   v = v | (v >> 1);
   v = v | (v >> 2);
   v = v | (v >> 4);
@@ -94,33 +83,46 @@ int CountLeadingZeroes<uint32_t>(uint32_t v) {
   return v ? (int)tbl[((uint32_t)(v * 0x07C4ACDDU)) >> 27] : 32;
 }
 
-template<>
-int CountLeadingZeroes<uint64_t>(uint64_t v) {
+template<> int CountLeadingZeroes<uint64_t>(uint64_t v) {
   return v >> 32 ? CountLeadingZeroes((uint32_t)(v >> 32))
                  : 32 + CountLeadingZeroes((uint32_t)v);
 }
 
 uint32_t Log2(uint32_t v) {
   switch (v) {
-    default: WASM_UNREACHABLE();
-    case 1: return 0;
-    case 2: return 1;
-    case 4: return 2;
-    case 8: return 3;
-    case 16: return 4;
-    case 32: return 5;
+    default:
+      WASM_UNREACHABLE();
+    case 1:
+      return 0;
+    case 2:
+      return 1;
+    case 4:
+      return 2;
+    case 8:
+      return 3;
+    case 16:
+      return 4;
+    case 32:
+      return 5;
   }
 }
 
 uint32_t Pow2(uint32_t v) {
   switch (v) {
-    case 0: return 1;
-    case 1: return 2;
-    case 2: return 4;
-    case 3: return 8;
-    case 4: return 16;
-    case 5: return 32;
-    default: return 1 << v;
+    case 0:
+      return 1;
+    case 1:
+      return 2;
+    case 2:
+      return 4;
+    case 3:
+      return 8;
+    case 4:
+      return 16;
+    case 5:
+      return 32;
+    default:
+      return 1 << v;
   }
 }
 
diff --git a/src/support/bits.h b/src/support/bits.h
index f1dc4364f..f2241bea8 100644
--- a/src/support/bits.h
+++ b/src/support/bits.h
@@ -56,31 +56,23 @@ extern template int CountLeadingZeroes(uint64_t);
 
 // Convenience signed -> unsigned. It usually doesn't make much sense to use bit
 // functions on signed types.
-template<typename T>
-int PopCount(T v) {
+template<typename T> int PopCount(T v) {
   return PopCount(typename std::make_unsigned<T>::type(v));
 }
-template<typename T>
-int CountTrailingZeroes(T v) {
+template<typename T> int CountTrailingZeroes(T v) {
   return CountTrailingZeroes(typename std::make_unsigned<T>::type(v));
 }
-template<typename T>
-int CountLeadingZeroes(T v) {
+template<typename T> int CountLeadingZeroes(T v) {
   return CountLeadingZeroes(typename std::make_unsigned<T>::type(v));
 }
-template<typename T>
-bool IsPowerOf2(T v) {
-  return v != 0 && PopCount(v) == 1;
-}
+template<typename T> bool IsPowerOf2(T v) { return v != 0 && PopCount(v) == 1; }
 
-template<typename T, typename U>
-inline static T RotateLeft(T val, U count) {
+template<typename T, typename U> inline static T RotateLeft(T val, U count) {
   T mask = sizeof(T) * CHAR_BIT - 1;
   count &= mask;
   return (val << count) | (val >> (-count & mask));
 }
-template<typename T, typename U>
-inline static T RotateRight(T val, U count) {
+template<typename T, typename U> inline static T RotateRight(T val, U count) {
   T mask = sizeof(T) * CHAR_BIT - 1;
   count &= mask;
   return (val >> count) | (val << (-count & mask));
@@ -89,6 +81,6 @@ inline static T RotateRight(T val, U count) {
 extern uint32_t Log2(uint32_t v);
 extern uint32_t Pow2(uint32_t v);
 
-}  // namespace wasm
+} // namespace wasm
 
-#endif  // wasm_support_bits_h
+#endif // wasm_support_bits_h
diff --git a/src/support/colors.cpp b/src/support/colors.cpp
index 7d78306e0..d0dc5ceb3 100644
--- a/src/support/colors.cpp
+++ b/src/support/colors.cpp
@@ -21,7 +21,7 @@
 
 namespace {
 bool colors_disabled = false;
-}  // anonymous namespace
+} // anonymous namespace
 
 void Colors::disable() { colors_disabled = true; }
 
@@ -30,25 +30,27 @@ void Colors::disable() { colors_disabled = true; }
 
 void Colors::outputColorCode(std::ostream& stream, const char* colorCode) {
   const static bool has_color = []() {
-    return (getenv("COLORS") && getenv("COLORS")[0] == '1') ||  // forced
+    return (getenv("COLORS") && getenv("COLORS")[0] == '1') || // forced
            (isatty(STDOUT_FILENO) &&
-            (!getenv("COLORS") || getenv("COLORS")[0] != '0'));  // implicit
+            (!getenv("COLORS") || getenv("COLORS")[0] != '0')); // implicit
   }();
-  if (has_color && !colors_disabled) stream << colorCode;
+  if (has_color && !colors_disabled)
+    stream << colorCode;
 }
 #elif defined(_WIN32)
-#include <windows.h>
 #include <io.h>
 #include <iostream>
+#include <windows.h>
 
-void Colors::outputColorCode(std::ostream&stream, const WORD &colorCode) {
+void Colors::outputColorCode(std::ostream& stream, const WORD& colorCode) {
   const static bool has_color = []() {
     return _isatty(_fileno(stdout)) &&
-            (!getenv("COLORS") || getenv("COLORS")[0] != '0');  // implicit
+           (!getenv("COLORS") || getenv("COLORS")[0] != '0'); // implicit
   }();
   static HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
   static HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
   if (has_color && !colors_disabled)
-    SetConsoleTextAttribute(&stream == &std::cout ? hStdout : hStderr, colorCode);
+    SetConsoleTextAttribute(&stream == &std::cout ? hStdout : hStderr,
+                            colorCode);
 }
 #endif
diff --git a/src/support/colors.h b/src/support/colors.h
index 6761639d9..68a251969 100644
--- a/src/support/colors.h
+++ b/src/support/colors.h
@@ -23,17 +23,21 @@ namespace Colors {
 void disable();
 
 #if defined(__linux__) || defined(__APPLE__)
-void outputColorCode(std::ostream& stream, const char *colorCode);
-inline void normal(std::ostream& stream) { outputColorCode(stream,"\033[0m"); }
-inline void red(std::ostream& stream) { outputColorCode(stream,"\033[31m"); }
-inline void magenta(std::ostream& stream) { outputColorCode(stream,"\033[35m"); }
-inline void orange(std::ostream& stream) { outputColorCode(stream,"\033[33m"); }
-inline void grey(std::ostream& stream) { outputColorCode(stream,"\033[37m"); }
-inline void green(std::ostream& stream) { outputColorCode(stream,"\033[32m"); }
-inline void blue(std::ostream& stream) { outputColorCode(stream,"\033[34m"); }
-inline void bold(std::ostream& stream) { outputColorCode(stream,"\033[1m"); }
+void outputColorCode(std::ostream& stream, const char* colorCode);
+inline void normal(std::ostream& stream) { outputColorCode(stream, "\033[0m"); }
+inline void red(std::ostream& stream) { outputColorCode(stream, "\033[31m"); }
+inline void magenta(std::ostream& stream) {
+  outputColorCode(stream, "\033[35m");
+}
+inline void orange(std::ostream& stream) {
+  outputColorCode(stream, "\033[33m");
+}
+inline void grey(std::ostream& stream) { outputColorCode(stream, "\033[37m"); }
+inline void green(std::ostream& stream) { outputColorCode(stream, "\033[32m"); }
+inline void blue(std::ostream& stream) { outputColorCode(stream, "\033[34m"); }
+inline void bold(std::ostream& stream) { outputColorCode(stream, "\033[1m"); }
 #elif defined(_WIN32)
-void outputColorCode(std::ostream& stream, const unsigned short &colorCode);
+void outputColorCode(std::ostream& stream, const unsigned short& colorCode);
 inline void normal(std::ostream& stream) { outputColorCode(stream, 0x07); }
 inline void red(std::ostream& stream) { outputColorCode(stream, 0x0c); }
 inline void magenta(std::ostream& stream) { outputColorCode(stream, 0x05); }
@@ -41,7 +45,8 @@ inline void orange(std::ostream& stream) { outputColorCode(stream, 0x06); }
 inline void grey(std::ostream& stream) { outputColorCode(stream, 0x08); }
 inline void green(std::ostream& stream) { outputColorCode(stream, 0x02); }
 inline void blue(std::ostream& stream) { outputColorCode(stream, 0x09); }
-inline void bold(std::ostream& stream) { /* Do nothing */ }
+inline void bold(std::ostream& stream) { /* Do nothing */
+}
 #else
 inline void normal(std::ostream& stream) {}
 inline void red(std::ostream& stream) {}
@@ -52,6 +57,6 @@ inline void green(std::ostream& stream) {}
 inline void blue(std::ostream& stream) {}
 inline void bold(std::ostream& stream) {}
 #endif
-}
+} // namespace Colors
 
 #endif // wasm_support_color_h
diff --git a/src/support/command-line.cpp b/src/support/command-line.cpp
index 6882dda7b..f3b9ffe25 100644
--- a/src/support/command-line.cpp
+++ b/src/support/command-line.cpp
@@ -37,7 +37,8 @@ void printWrap(std::ostream& os, int leftPad, const std::string& content) {
       }
       os << nextWord;
       space -= nextWord.size() + 1;
-      if (space > 0) os << ' ';
+      if (space > 0)
+        os << ' ';
       nextWord.clear();
       if (content[i] == '\n') {
         os << '\n';
@@ -48,18 +49,22 @@ void printWrap(std::ostream& os, int leftPad, const std::string& content) {
 }
 
 Options::Options(const std::string& command, const std::string& description)
-    : debug(false), positional(Arguments::Zero) {
-  add("--help", "-h", "Show this help message and exit", Arguments::Zero,
+  : debug(false), positional(Arguments::Zero) {
+  add("--help",
+      "-h",
+      "Show this help message and exit",
+      Arguments::Zero,
       [this, command, description](Options* o, const std::string&) {
         std::cout << command;
-        if (positional != Arguments::Zero) std::cout << ' ' << positionalName;
+        if (positional != Arguments::Zero)
+          std::cout << ' ' << positionalName;
         std::cout << "\n\n";
         printWrap(std::cout, 0, description);
         std::cout << "\n\nOptions:\n";
         size_t optionWidth = 0;
         for (const auto& o : options) {
           optionWidth =
-              std::max(optionWidth, o.longName.size() + o.shortName.size());
+            std::max(optionWidth, o.longName.size() + o.shortName.size());
         }
         for (const auto& o : options) {
           bool long_n_short = o.longName.size() != 0 && o.shortName.size() != 0;
@@ -72,20 +77,26 @@ Options::Options(const std::string& command, const std::string& description)
         std::cout << '\n';
         exit(EXIT_SUCCESS);
       });
-  add("--debug", "-d", "Print debug information to stderr", Arguments::Zero,
+  add("--debug",
+      "-d",
+      "Print debug information to stderr",
+      Arguments::Zero,
       [&](Options* o, const std::string& arguments) { debug = true; });
 }
 
 Options::~Options() {}
 
-Options& Options::add(const std::string& longName, const std::string& shortName,
-                      const std::string& description, Arguments arguments,
+Options& Options::add(const std::string& longName,
+                      const std::string& shortName,
+                      const std::string& description,
+                      Arguments arguments,
                       const Action& action) {
   options.push_back({longName, shortName, description, arguments, action, 0});
   return *this;
 }
 
-Options& Options::add_positional(const std::string& name, Arguments arguments,
+Options& Options::add_positional(const std::string& name,
+                                 Arguments arguments,
                                  const Action& action) {
   positional = arguments;
   positionalName = name;
@@ -98,7 +109,8 @@ void Options::parse(int argc, const char* argv[]) {
   size_t positionalsSeen = 0;
   auto dashes = [](const std::string& s) {
     for (size_t i = 0;; ++i) {
-      if (s[i] != '-') return i;
+      if (s[i] != '-')
+        return i;
     }
   };
   for (size_t i = 1, e = argc; i != e; ++i) {
@@ -169,7 +181,8 @@ void Options::parse(int argc, const char* argv[]) {
         break;
       case Arguments::Optional:
         if (!argument.size()) {
-          if (i + 1 != e) argument = argv[++i];
+          if (i + 1 != e)
+            argument = argv[++i];
         }
         break;
     }
diff --git a/src/support/command-line.h b/src/support/command-line.h
index de773bfa8..82193244e 100644
--- a/src/support/command-line.h
+++ b/src/support/command-line.h
@@ -29,12 +29,11 @@
 
 #include "wasm.h"
 
-
 namespace wasm {
 
 class Options {
- public:
-  using Action = std::function<void(Options *, const std::string& )>;
+public:
+  using Action = std::function<void(Options*, const std::string&)>;
   enum class Arguments { Zero, One, N, Optional };
 
   bool debug;
@@ -42,17 +41,20 @@ class Options {
 
   Options(const std::string& command, const std::string& description);
   ~Options();
-  Options &add(const std::string& longName, const std::string& shortName,
-               const std::string& description, Arguments arguments,
+  Options& add(const std::string& longName,
+               const std::string& shortName,
+               const std::string& description,
+               Arguments arguments,
                const Action& action);
-  Options &add_positional(const std::string& name, Arguments arguments,
-                          const Action &action);
-  void parse(int argc, const char *argv[]);
+  Options& add_positional(const std::string& name,
+                          Arguments arguments,
+                          const Action& action);
+  void parse(int argc, const char* argv[]);
 
- private:
+private:
   Options() = delete;
-  Options(const Options &) = delete;
-  Options &operator=(const Options &) = delete;
+  Options(const Options&) = delete;
+  Options& operator=(const Options&) = delete;
 
   struct Option {
     std::string longName;
@@ -68,6 +70,6 @@ class Options {
   Action positionalAction;
 };
 
-}  // namespace wasm
+} // namespace wasm
 
 #endif // wasm_support_command_line_h
diff --git a/src/support/file.cpp b/src/support/file.cpp
index c10646720..3af7af44b 100644
--- a/src/support/file.cpp
+++ b/src/support/file.cpp
@@ -16,13 +16,14 @@
 
 #include "support/file.h"
 
-#include <iostream>
-#include <cstdlib>
 #include <cstdint>
+#include <cstdlib>
+#include <iostream>
 #include <limits>
 
 std::vector<char> wasm::read_stdin(Flags::DebugOption debug) {
-  if (debug == Flags::Debug) std::cerr << "Loading stdin..." << std::endl;
+  if (debug == Flags::Debug)
+    std::cerr << "Loading stdin..." << std::endl;
   std::vector<char> input;
   char c;
   while (std::cin.get(c) && !std::cin.eof()) {
@@ -31,13 +32,16 @@ std::vector<char> wasm::read_stdin(Flags::DebugOption debug) {
   return input;
 }
 
-
 template<typename T>
-T wasm::read_file(const std::string& filename, Flags::BinaryOption binary, Flags::DebugOption debug) {
-  if (debug == Flags::Debug) std::cerr << "Loading '" << filename << "'..." << std::endl;
+T wasm::read_file(const std::string& filename,
+                  Flags::BinaryOption binary,
+                  Flags::DebugOption debug) {
+  if (debug == Flags::Debug)
+    std::cerr << "Loading '" << filename << "'..." << std::endl;
   std::ifstream infile;
   std::ios_base::openmode flags = std::ifstream::in;
-  if (binary == Flags::Binary) flags |= std::ifstream::binary;
+  if (binary == Flags::Binary)
+    flags |= std::ifstream::binary;
   infile.open(filename, flags);
   if (!infile.is_open()) {
     std::cerr << "Failed opening '" << filename << "'" << std::endl;
@@ -46,47 +50,60 @@ T wasm::read_file(const std::string& filename, Flags::BinaryOption binary, Flags
   infile.seekg(0, std::ios::end);
   std::streampos insize = infile.tellg();
   if (uint64_t(insize) >= std::numeric_limits<size_t>::max()) {
-    // Building a 32-bit executable where size_t == 32 bits, we are not able to create strings larger than 2^32 bytes in length, so must abort here.
-    std::cerr << "Failed opening '" << filename << "': Input file too large: " << insize << " bytes. Try rebuilding in 64-bit mode." << std::endl;
+    // Building a 32-bit executable where size_t == 32 bits, we are not able to
+    // create strings larger than 2^32 bytes in length, so must abort here.
+    std::cerr << "Failed opening '" << filename
+              << "': Input file too large: " << insize
+              << " bytes. Try rebuilding in 64-bit mode." << std::endl;
     exit(EXIT_FAILURE);
   }
   T input(size_t(insize) + (binary == Flags::Binary ? 0 : 1), '\0');
-  if (size_t(insize) == 0) return input;
+  if (size_t(insize) == 0)
+    return input;
   infile.seekg(0);
   infile.read(&input[0], insize);
   if (binary == Flags::Text) {
     size_t chars = size_t(infile.gcount());
-    input.resize(chars+1); // Truncate size to the number of ASCII characters actually read in text mode (which is generally less than the number of bytes on Windows, if \r\n line endings are present)
+    // Truncate size to the number of ASCII characters actually read in text
+    // mode (which is generally less than the number of bytes on Windows, if
+    // \r\n line endings are present)
+    input.resize(chars + 1);
     input[chars] = '\0';
   }
   return input;
 }
 
 // Explicit instantiations for the explicit specializations.
-template std::string wasm::read_file<>(const std::string& , Flags::BinaryOption, Flags::DebugOption);
-template std::vector<char> wasm::read_file<>(const std::string& , Flags::BinaryOption, Flags::DebugOption);
+template std::string
+wasm::read_file<>(const std::string&, Flags::BinaryOption, Flags::DebugOption);
+template std::vector<char>
+wasm::read_file<>(const std::string&, Flags::BinaryOption, Flags::DebugOption);
 
-wasm::Output::Output(const std::string& filename, Flags::BinaryOption binary, Flags::DebugOption debug)
-    : outfile(), out([this, filename, binary, debug]() {
-        if (filename == "-") {
-          return std::cout.rdbuf();
-        }
-        std::streambuf *buffer;
-        if (filename.size()) {
-          if (debug == Flags::Debug) std::cerr << "Opening '" << filename << "'" << std::endl;
-          auto flags = std::ofstream::out | std::ofstream::trunc;
-          if (binary == Flags::Binary) flags |= std::ofstream::binary;
-          outfile.open(filename, flags);
-          if (!outfile.is_open()) {
-            std::cerr << "Failed opening '" << filename << "'" << std::endl;
-            exit(EXIT_FAILURE);
-          }
-          buffer = outfile.rdbuf();
-        } else {
-          buffer = std::cout.rdbuf();
+wasm::Output::Output(const std::string& filename,
+                     Flags::BinaryOption binary,
+                     Flags::DebugOption debug)
+  : outfile(), out([this, filename, binary, debug]() {
+      if (filename == "-") {
+        return std::cout.rdbuf();
+      }
+      std::streambuf* buffer;
+      if (filename.size()) {
+        if (debug == Flags::Debug)
+          std::cerr << "Opening '" << filename << "'" << std::endl;
+        auto flags = std::ofstream::out | std::ofstream::trunc;
+        if (binary == Flags::Binary)
+          flags |= std::ofstream::binary;
+        outfile.open(filename, flags);
+        if (!outfile.is_open()) {
+          std::cerr << "Failed opening '" << filename << "'" << std::endl;
+          exit(EXIT_FAILURE);
         }
-        return buffer;
-      }()) {}
+        buffer = outfile.rdbuf();
+      } else {
+        buffer = std::cout.rdbuf();
+      }
+      return buffer;
+    }()) {}
 
 void wasm::copy_file(std::string input, std::string output) {
   std::ifstream src(input, std::ios::binary);
diff --git a/src/support/file.h b/src/support/file.h
index cb9c82ca9..67d63315b 100644
--- a/src/support/file.h
+++ b/src/support/file.h
@@ -29,46 +29,41 @@
 namespace wasm {
 
 namespace Flags {
-  enum BinaryOption {
-    Binary,
-    Text
-  };
-  enum DebugOption {
-    Debug,
-    Release
-  };
-}
+enum BinaryOption { Binary, Text };
+enum DebugOption { Debug, Release };
+} // namespace Flags
 
 std::vector<char> read_stdin(Flags::DebugOption);
 
 template<typename T>
-T read_file(const std::string& filename, Flags::BinaryOption binary, Flags::DebugOption debug);
+T read_file(const std::string& filename,
+            Flags::BinaryOption binary,
+            Flags::DebugOption debug);
 // Declare the valid explicit specializations.
-extern template std::string read_file<>(const std::string& , Flags::BinaryOption, Flags::DebugOption);
-extern template std::vector<char> read_file<>(const std::string& , Flags::BinaryOption, Flags::DebugOption);
+extern template std::string
+read_file<>(const std::string&, Flags::BinaryOption, Flags::DebugOption);
+extern template std::vector<char>
+read_file<>(const std::string&, Flags::BinaryOption, Flags::DebugOption);
 
 class Output {
- public:
+public:
   // An empty filename will open stdout instead.
-  Output(const std::string& filename, Flags::BinaryOption binary, Flags::DebugOption debug);
+  Output(const std::string& filename,
+         Flags::BinaryOption binary,
+         Flags::DebugOption debug);
   ~Output() = default;
-  template<typename T>
-  std::ostream &operator<<(const T &v) {
-    return out << v;
-  }
+  template<typename T> std::ostream& operator<<(const T& v) { return out << v; }
 
-  std::ostream& getStream() {
-    return out;
-  }
+  std::ostream& getStream() { return out; }
 
   std::ostream& write(const char* s, std::streamsize c) {
     return out.write(s, c);
   }
 
- private:
+private:
   Output() = delete;
-  Output(const Output &) = delete;
-  Output &operator=(const Output &) = delete;
+  Output(const Output&) = delete;
+  Output& operator=(const Output&) = delete;
   std::ofstream outfile;
   std::ostream out;
 };
@@ -81,4 +76,4 @@ size_t file_size(std::string filename);
 
 } // namespace wasm
 
-#endif  // wasm_support_file_h
+#endif // wasm_support_file_h
diff --git a/src/support/hash.h b/src/support/hash.h
index 98d7ceead..647369ac8 100644
--- a/src/support/hash.h
+++ b/src/support/hash.h
@@ -25,7 +25,8 @@ namespace wasm {
 typedef uint32_t HashType;
 
 inline HashType rehash(HashType x, HashType y) {
-  // see http://www.cse.yorku.ca/~oz/hash.html and https://stackoverflow.com/a/2595226/1176841
+  // see http://www.cse.yorku.ca/~oz/hash.html and
+  // https://stackoverflow.com/a/2595226/1176841
   HashType hash = 5381;
   while (x) {
     hash = ((hash << 5) + hash) ^ (x & 0xff);
diff --git a/src/support/json.h b/src/support/json.h
index 7ffa1211f..8f2edc04d 100644
--- a/src/support/json.h
+++ b/src/support/json.h
@@ -50,12 +50,8 @@ struct Value {
     Ref() = default;
     Ref(Value* value) : std::shared_ptr<Value>(value) {}
 
-    Ref& operator[](size_t x) {
-      return (*this->get())[x];
-    }
-    Ref& operator[](IString x) {
-      return (*this->get())[x];
-    }
+    Ref& operator[](size_t x) { return (*this->get())[x]; }
+    Ref& operator[](IString x) { return (*this->get())[x]; }
   };
 
   enum Type {
@@ -72,7 +68,9 @@ struct Value {
   typedef std::vector<Ref> ArrayStorage;
   typedef std::unordered_map<IString, Ref> ObjectStorage;
 
-#ifdef _MSC_VER // MSVC does not allow unrestricted unions: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+  // MSVC does not allow unrestricted unions:
+  // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
+#ifdef _MSC_VER
   IString str;
 #endif
   union { // TODO: optimize
@@ -80,29 +78,24 @@ struct Value {
     IString str;
 #endif
     double num = 0;
-    ArrayStorage *arr; // manually allocated/freed
+    ArrayStorage* arr; // manually allocated/freed
     bool boo;
-    ObjectStorage *obj; // manually allocated/freed
+    ObjectStorage* obj; // manually allocated/freed
     Ref ref;
   };
 
   // constructors all copy their input
   Value() {}
-  explicit Value(const char *s) : type(Null) {
-    setString(s);
-  }
-  explicit Value(double n) : type(Null) {
-    setNumber(n);
-  }
-  explicit Value(ArrayStorage &a) : type(Null) {
+  explicit Value(const char* s) : type(Null) { setString(s); }
+  explicit Value(double n) : type(Null) { setNumber(n); }
+  explicit Value(ArrayStorage& a) : type(Null) {
     setArray();
     *arr = a;
   }
-  // no bool constructor - would endanger the double one (int might convert the wrong way)
+  // no bool constructor - would endanger the double one (int might convert the
+  // wrong way)
 
-  ~Value() {
-    free();
-  }
+  ~Value() { free(); }
 
   void free() {
     if (type == Array) {
@@ -116,13 +109,13 @@ struct Value {
     num = 0;
   }
 
-  Value& setString(const char *s) {
+  Value& setString(const char* s) {
     free();
     type = String;
     str.set(s);
     return *this;
   }
-  Value& setString(const IString &s) {
+  Value& setString(const IString& s) {
     free();
     type = String;
     str.set(s);
@@ -134,14 +127,14 @@ struct Value {
     num = n;
     return *this;
   }
-  Value& setArray(ArrayStorage &a) {
+  Value& setArray(ArrayStorage& a) {
     free();
     type = Array;
     arr = new ArrayStorage;
     *arr = a;
     return *this;
   }
-  Value& setArray(size_t size_hint=0) {
+  Value& setArray(size_t size_hint = 0) {
     free();
     type = Array;
     arr = new ArrayStorage;
@@ -153,7 +146,8 @@ struct Value {
     type = Null;
     return *this;
   }
-  Value& setBool(bool b) { // Bool in the name, as otherwise might overload over int
+  Value&
+  setBool(bool b) { // Bool in the name, as otherwise might overload over int
     free();
     type = Bool;
     boo = b;
@@ -168,12 +162,14 @@ struct Value {
 
   bool isString() { return type == String; }
   bool isNumber() { return type == Number; }
-  bool isArray()  { return type == Array; }
-  bool isNull()   { return type == Null; }
-  bool isBool()   { return type == Bool; }
+  bool isArray() { return type == Array; }
+  bool isNull() { return type == Null; }
+  bool isBool() { return type == Bool; }
   bool isObject() { return type == Object; }
 
-  bool isBool(bool b) { return type == Bool && b == boo; } // avoid overloading == as it might overload over int
+  bool isBool(bool b) {
+    return type == Bool && b == boo;
+  } // avoid overloading == as it might overload over int
 
   const char* getCString() {
     assert(isString());
@@ -228,7 +224,8 @@ struct Value {
   }
 
   bool operator==(const Value& other) {
-    if (type != other.type) return false;
+    if (type != other.type)
+      return false;
     switch (other.type) {
       case String:
         return str == other.str;
@@ -249,17 +246,23 @@ struct Value {
   }
 
   char* parse(char* curr) {
-    #define is_json_space(x) (x == 32 || x == 9 || x == 10 || x == 13) /* space, tab, linefeed/newline, or return */
-    #define skip() { while (*curr && is_json_space(*curr)) curr++; }
+#define is_json_space(x)                                                       \
+  (x == 32 || x == 9 || x == 10 ||                                             \
+   x == 13) /* space, tab, linefeed/newline, or return */
+#define skip()                                                                 \
+  {                                                                            \
+    while (*curr && is_json_space(*curr))                                      \
+      curr++;                                                                  \
+  }
     skip();
     if (*curr == '"') {
       // String
       curr++;
-      char *close = strchr(curr, '"');
+      char* close = strchr(curr, '"');
       assert(close);
       *close = 0; // end this string, and reuse it straight from the input
       setString(curr);
-      curr = close+1;
+      curr = close + 1;
     } else if (*curr == '[') {
       // Array
       curr++;
@@ -270,7 +273,8 @@ struct Value {
         arr->push_back(temp);
         curr = temp->parse(curr);
         skip();
-        if (*curr == ']') break;
+        if (*curr == ']')
+          break;
         assert(*curr == ',');
         curr++;
         skip();
@@ -299,11 +303,11 @@ struct Value {
       while (*curr != '}') {
         assert(*curr == '"');
         curr++;
-        char *close = strchr(curr, '"');
+        char* close = strchr(curr, '"');
         assert(close);
         *close = 0; // end this string, and reuse it straight from the input
         IString key(curr);
-        curr = close+1;
+        curr = close + 1;
         skip();
         assert(*curr == ':');
         curr++;
@@ -312,7 +316,8 @@ struct Value {
         curr = value->parse(curr);
         (*obj)[key] = value;
         skip();
-        if (*curr == '}') break;
+        if (*curr == '}')
+          break;
         assert(*curr == ',');
         curr++;
         skip();
@@ -320,14 +325,14 @@ struct Value {
       curr++;
     } else {
       // Number
-      char *after;
+      char* after;
       setNumber(strtod(curr, &after));
       curr = after;
     }
     return curr;
   }
 
-  void stringify(std::ostream &os, bool pretty=false);
+  void stringify(std::ostream& os, bool pretty = false);
 
   // String operations
 
@@ -343,7 +348,8 @@ struct Value {
   void setSize(size_t size) {
     assert(isArray());
     auto old = arr->size();
-    if (old != size) arr->resize(size);
+    if (old != size)
+      arr->resize(size);
     if (old < size) {
       for (auto i = old; i < size; i++) {
         (*arr)[i] = Ref(new Value());
@@ -370,7 +376,8 @@ struct Value {
 
   Ref back() {
     assert(isArray());
-    if (arr->size() == 0) return nullptr;
+    if (arr->size() == 0)
+      return nullptr;
     return arr->back();
   }
 
diff --git a/src/support/learning.h b/src/support/learning.h
index 8427a2362..0cdd4e929 100644
--- a/src/support/learning.h
+++ b/src/support/learning.h
@@ -33,7 +33,8 @@ namespace wasm {
 // The Generator must implement the following:
 //
 //  * Genome* makeRandom(); - make a random element
-//  * Genome* makeMixture(Genome* one, Genome* two); - make a new element by mixing two
+//  * Genome* makeMixture(Genome* one, Genome* two); - make a new element by
+//    mixing two
 //
 // Fitness is the type of the fitness values, e.g. uint32_t. More is better.
 //
@@ -51,19 +52,20 @@ class GeneticLearner {
   std::vector<unique_ptr> population;
 
   void sort() {
-    std::sort(population.begin(), population.end(), [](const unique_ptr& left, const unique_ptr& right) {
-      return left->getFitness() > right->getFitness();
-    });
+    std::sort(population.begin(),
+              population.end(),
+              [](const unique_ptr& left, const unique_ptr& right) {
+                return left->getFitness() > right->getFitness();
+              });
   }
 
   std::mt19937 noise;
 
-  size_t randomIndex() {
-    return noise() % population.size();
-  }
+  size_t randomIndex() { return noise() % population.size(); }
 
 public:
-  GeneticLearner(Generator& generator, size_t size) : generator(generator), noise(1337) {
+  GeneticLearner(Generator& generator, size_t size)
+    : generator(generator), noise(1337) {
     population.resize(size);
     for (size_t i = 0; i < size; i++) {
       population[i] = unique_ptr(generator.makeRandom());
@@ -71,27 +73,26 @@ public:
     sort();
   }
 
-  Genome* getBest() {
-    return population[0].get();
-  }
+  Genome* getBest() { return population[0].get(); }
 
-  unique_ptr acquireBest() {
-    return population[0];
-  }
+  unique_ptr acquireBest() { return population[0]; }
 
   void runGeneration() {
     size_t size = population.size();
 
-    // we have a mix of promoted from the last generation, mixed from the last generation, and random
+    // we have a mix of promoted from the last generation, mixed from the last
+    // generation, and random
     const size_t promoted = (25 * size) / 100;
     const size_t mixed = (50 * size) / 100;
 
     // promoted just stay in place
-    // mixtures are computed, then added back in (as we still need them as we work)
+    // mixtures are computed, then added back in (as we still need them as we
+    // work)
     std::vector<unique_ptr> mixtures;
     mixtures.resize(mixed);
     for (size_t i = 0; i < mixed; i++) {
-      mixtures[i] = unique_ptr(generator.makeMixture(population[randomIndex()].get(), population[randomIndex()].get()));
+      mixtures[i] = unique_ptr(generator.makeMixture(
+        population[randomIndex()].get(), population[randomIndex()].get()));
     }
     for (size_t i = 0; i < mixed; i++) {
       population[promoted + i].swap(mixtures[i]);
@@ -106,6 +107,6 @@ public:
   }
 };
 
-}  // namespace wasm
+} // namespace wasm
 
-#endif  // wasm_learning_h
+#endif // wasm_learning_h
diff --git a/src/support/name.h b/src/support/name.h
index 0a745b2f7..6f17c3ebf 100644
--- a/src/support/name.h
+++ b/src/support/name.h
@@ -41,7 +41,8 @@ struct Name : public cashew::IString {
 
   friend std::ostream& operator<<(std::ostream& o, Name name) {
     if (name.str) {
-      return o << '$' << name.str; // reference interpreter requires we prefix all names
+      // reference interpreter requires we prefix all names
+      return o << '$' << name.str;
     } else {
       return o << "(null Name)";
     }
@@ -64,5 +65,4 @@ template<> struct hash<wasm::Name> : hash<cashew::IString> {};
 
 } // namespace std
 
-
 #endif // wasm_support_string_h
diff --git a/src/support/path.cpp b/src/support/path.cpp
index 322099a95..7ae68d719 100644
--- a/src/support/path.cpp
+++ b/src/support/path.cpp
@@ -27,7 +27,7 @@ namespace Path {
 std::string getPathSeparator() {
   // TODO: use c++17's path separator
   //       http://en.cppreference.com/w/cpp/experimental/fs/path
-#if defined(WIN32) || defined(_WIN32) 
+#if defined(WIN32) || defined(_WIN32)
   return "\\";
 #else
   return "/";
@@ -36,7 +36,8 @@ std::string getPathSeparator() {
 
 std::string getBinaryenRoot() {
   auto* envVar = getenv("BINARYEN_ROOT");
-  if (envVar) return envVar;
+  if (envVar)
+    return envVar;
   return ".";
 }
 
@@ -50,9 +51,7 @@ std::string getBinaryenBinDir() {
   }
 }
 
-void setBinaryenBinDir(std::string dir) {
-  binDir = dir;
-}
+void setBinaryenBinDir(std::string dir) { binDir = dir; }
 
 // Gets the path to a binaryen binary tool, like wasm-opt
 std::string getBinaryenBinaryTool(std::string name) {
@@ -62,4 +61,3 @@ std::string getBinaryenBinaryTool(std::string name) {
 } // namespace Path
 
 } // namespace wasm
-
diff --git a/src/support/safe_integer.cpp b/src/support/safe_integer.cpp
index ca5052cd2..23ef84b22 100644
--- a/src/support/safe_integer.cpp
+++ b/src/support/safe_integer.cpp
@@ -35,17 +35,18 @@ bool wasm::isSInteger32(double x) {
 }
 
 uint32_t wasm::toUInteger32(double x) {
-  return std::signbit(x) ? 0 : (x < std::numeric_limits<uint32_t>::max()
-                                    ? (uint32_t)x
-                                    : std::numeric_limits<uint32_t>::max());
+  return std::signbit(x) ? 0
+                         : (x < std::numeric_limits<uint32_t>::max()
+                              ? (uint32_t)x
+                              : std::numeric_limits<uint32_t>::max());
 }
 
 int32_t wasm::toSInteger32(double x) {
   return (x > std::numeric_limits<int32_t>::min() &&
           x < std::numeric_limits<int32_t>::max())
-             ? (int32_t)x
-             : (std::signbit(x) ? std::numeric_limits<int32_t>::min()
-                                : std::numeric_limits<int32_t>::max());
+           ? (int32_t)x
+           : (std::signbit(x) ? std::numeric_limits<int32_t>::min()
+                              : std::numeric_limits<int32_t>::max());
 }
 
 bool wasm::isUInteger64(double x) {
@@ -59,17 +60,18 @@ bool wasm::isSInteger64(double x) {
 }
 
 uint64_t wasm::toUInteger64(double x) {
-  return std::signbit(x) ? 0 : (x < (double)std::numeric_limits<uint64_t>::max()
-                                    ? (uint64_t)x
-                                    : std::numeric_limits<uint64_t>::max());
+  return std::signbit(x) ? 0
+                         : (x < (double)std::numeric_limits<uint64_t>::max()
+                              ? (uint64_t)x
+                              : std::numeric_limits<uint64_t>::max());
 }
 
 int64_t wasm::toSInteger64(double x) {
   return (x > (double)std::numeric_limits<int64_t>::min() &&
           x < (double)std::numeric_limits<int64_t>::max())
-             ? (int64_t)x
-             : (std::signbit(x) ? std::numeric_limits<int64_t>::min()
-                                : std::numeric_limits<int64_t>::max());
+           ? (int64_t)x
+           : (std::signbit(x) ? std::numeric_limits<int64_t>::min()
+                              : std::numeric_limits<int64_t>::max());
 }
 
 /* 3 32222222 222...00
@@ -116,6 +118,7 @@ bool wasm::isInRangeI64TruncU(int32_t i) {
   return (u < 0x5f800000U) || (u >= 0x80000000U && u < 0xbf800000U);
 }
 
+/* clang-format off */
 /*
  * 6 66655555555 5544...222221...000
  * 3 21098765432 1098...432109...210
@@ -139,6 +142,7 @@ bool wasm::isInRangeI64TruncU(int32_t i) {
  * 1 11111111111 0000...000000...001 0xfff0000000000001 => -nan(0x1)
  * 1 11111111111 1111...111111...111 0xffffffffffffffff => -nan(0xfff...)
  */
+/* clang-format on */
 
 bool wasm::isInRangeI32TruncS(int64_t i) {
   uint64_t u = i;
diff --git a/src/support/safe_integer.h b/src/support/safe_integer.h
index 5bd807a18..031c6c323 100644
--- a/src/support/safe_integer.h
+++ b/src/support/safe_integer.h
@@ -41,6 +41,6 @@ bool isInRangeI32TruncU(int64_t i);
 bool isInRangeI64TruncS(int64_t i);
 bool isInRangeI64TruncU(int64_t i);
 
-}  // namespace wasm
+} // namespace wasm
 
-#endif  // wasm_safe_integer_h
+#endif // wasm_safe_integer_h
diff --git a/src/support/small_vector.h b/src/support/small_vector.h
index e746700bf..dd6afb526 100644
--- a/src/support/small_vector.h
+++ b/src/support/small_vector.h
@@ -29,8 +29,7 @@
 
 namespace wasm {
 
-template<typename T, size_t N>
-class SmallVector {
+template<typename T, size_t N> class SmallVector {
   // fixed-space storage
   size_t usedFixed = 0;
   std::array<T, N> fixed;
@@ -65,10 +64,9 @@ public:
     }
   }
 
-  template <typename... ArgTypes>
-  void emplace_back(ArgTypes &&... Args) {
+  template<typename... ArgTypes> void emplace_back(ArgTypes&&... Args) {
     if (usedFixed < N) {
-      new(&fixed[usedFixed++]) T(std::forward<ArgTypes>(Args)...);
+      new (&fixed[usedFixed++]) T(std::forward<ArgTypes>(Args)...);
     } else {
       flexible.emplace_back(std::forward<ArgTypes>(Args)...);
     }
@@ -101,13 +99,9 @@ public:
     }
   }
 
-  size_t size() const {
-    return usedFixed + flexible.size();
-  }
+  size_t size() const { return usedFixed + flexible.size(); }
 
-  bool empty() const {
-    return size() == 0;
-  }
+  bool empty() const { return size() == 0; }
 
   void clear() {
     usedFixed = 0;
@@ -115,9 +109,11 @@ public:
   }
 
   bool operator==(const SmallVector<T, N>& other) const {
-    if (usedFixed != other.usedFixed) return false;
+    if (usedFixed != other.usedFixed)
+      return false;
     for (size_t i = 0; i < usedFixed; i++) {
-      if (fixed[i] != other.fixed[i]) return false;
+      if (fixed[i] != other.fixed[i])
+        return false;
     }
     return flexible == other.flexible;
   }
@@ -136,15 +132,14 @@ public:
     const SmallVector<T, N>* parent;
     size_t index;
 
-    Iterator(const SmallVector<T, N>* parent, size_t index) : parent(parent), index(index) {}
+    Iterator(const SmallVector<T, N>* parent, size_t index)
+      : parent(parent), index(index) {}
 
     bool operator!=(const Iterator& other) const {
       return index != other.index || parent != other.parent;
     }
 
-    void operator++() {
-      index++;
-    }
+    void operator++() { index++; }
 
     Iterator& operator+=(difference_type off) {
       index += off;
@@ -155,9 +150,7 @@ public:
       return Iterator(*this) += off;
     }
 
-    const value_type operator*() const {
-      return (*parent)[index];
-    }
+    const value_type operator*() const { return (*parent)[index]; }
   };
 
   Iterator begin() const {
diff --git a/src/support/sorted_vector.h b/src/support/sorted_vector.h
index da991ce78..e26d5e3af 100644
--- a/src/support/sorted_vector.h
+++ b/src/support/sorted_vector.h
@@ -61,7 +61,8 @@ struct SortedVector : public std::vector<Index> {
 
   void insert(Index x) {
     auto it = std::lower_bound(begin(), end(), x);
-    if (it == end()) push_back(x);
+    if (it == end())
+      push_back(x);
     else if (*it > x) {
       Index i = it - begin();
       resize(size() + 1);
@@ -85,8 +86,7 @@ struct SortedVector : public std::vector<Index> {
     return it != end() && *it == x;
   }
 
-  template<typename T>
-  SortedVector& filter(T keep) {
+  template<typename T> SortedVector& filter(T keep) {
     size_t skip = 0;
     for (size_t i = 0; i < size(); i++) {
       if (keep((*this)[i])) {
@@ -107,7 +107,8 @@ struct SortedVector : public std::vector<Index> {
 
   void dump(const char* str = nullptr) const {
     std::cout << "SortedVector " << (str ? str : "") << ": ";
-    for (auto x : *this) std::cout << x << " ";
+    for (auto x : *this)
+      std::cout << x << " ";
     std::cout << '\n';
   }
 };
diff --git a/src/support/threads.cpp b/src/support/threads.cpp
index 7ae304c4f..785994b4e 100644
--- a/src/support/threads.cpp
+++ b/src/support/threads.cpp
@@ -20,23 +20,29 @@
 #include <iostream>
 #include <string>
 
-#include "threads.h"
 #include "compiler-support.h"
+#include "threads.h"
 #include "utilities.h"
 
-
 // debugging tools
 
 #ifdef BINARYEN_THREAD_DEBUG
 static std::mutex debug;
-#define DEBUG_THREAD(x) { std::lock_guard<std::mutex> lock(debug); std::cerr << "[THREAD " << std::this_thread::get_id() << "] " << x; }
-#define DEBUG_POOL(x)   { std::lock_guard<std::mutex> lock(debug); std::cerr << "[POOL "   << std::this_thread::get_id() << "] " << x; }
+#define DEBUG_THREAD(x)                                                        \
+  {                                                                            \
+    std::lock_guard<std::mutex> lock(debug);                                   \
+    std::cerr << "[THREAD " << std::this_thread::get_id() << "] " << x;        \
+  }
+#define DEBUG_POOL(x)                                                          \
+  {                                                                            \
+    std::lock_guard<std::mutex> lock(debug);                                   \
+    std::cerr << "[POOL " << std::this_thread::get_id() << "] " << x;          \
+  }
 #else
 #define DEBUG_THREAD(x)
 #define DEBUG_POOL(x)
 #endif
 
-
 namespace wasm {
 
 // Thread
@@ -56,7 +62,7 @@ Thread::~Thread() {
   thread->join();
 }
 
-void Thread::work(std::function<ThreadWorkState ()> doWork_) {
+void Thread::work(std::function<ThreadWorkState()> doWork_) {
   // TODO: fancy work stealing
   DEBUG_THREAD("send work to thread\n");
   {
@@ -68,7 +74,7 @@ void Thread::work(std::function<ThreadWorkState ()> doWork_) {
   }
 }
 
-void Thread::mainLoop(void *self_) {
+void Thread::mainLoop(void* self_) {
   auto* self = static_cast<Thread*>(self_);
   while (1) {
     DEBUG_THREAD("checking for work\n");
@@ -77,7 +83,8 @@ void Thread::mainLoop(void *self_) {
       if (self->doWork) {
         DEBUG_THREAD("doing work\n");
         // run tasks until they are all done
-        while (self->doWork() == ThreadWorkState::More) {}
+        while (self->doWork() == ThreadWorkState::More) {
+        }
         self->doWork = nullptr;
       } else if (self->done) {
         DEBUG_THREAD("done\n");
@@ -107,16 +114,19 @@ std::mutex ThreadPool::workMutex;
 std::mutex ThreadPool::threadMutex;
 
 void ThreadPool::initialize(size_t num) {
-  if (num == 1) return; // no multiple cores, don't create threads
+  if (num == 1)
+    return; // no multiple cores, don't create threads
   DEBUG_POOL("initialize()\n");
   std::unique_lock<std::mutex> lock(threadMutex);
-  ready.store(threads.size()); // initial state before first resetThreadsAreReady()
+  // initial state before first resetThreadsAreReady()
+  ready.store(threads.size());
   resetThreadsAreReady();
   for (size_t i = 0; i < num; i++) {
     try {
       threads.emplace_back(make_unique<Thread>(this));
     } catch (std::system_error&) {
-      // failed to create a thread - don't use multithreading, as if num cores == 1
+      // failed to create a thread - don't use multithreading, as if num cores
+      // == 1
       DEBUG_POOL("could not create thread\n");
       threads.clear();
       return;
@@ -154,14 +164,16 @@ ThreadPool* ThreadPool::get() {
   return pool.get();
 }
 
-void ThreadPool::work(std::vector<std::function<ThreadWorkState ()>>& doWorkers) {
+void ThreadPool::work(
+  std::vector<std::function<ThreadWorkState()>>& doWorkers) {
   size_t num = threads.size();
   // If no multiple cores, or on a side thread, do not use worker threads
   if (num == 0) {
     // just run sequentially
     DEBUG_POOL("work() sequentially\n");
     assert(doWorkers.size() > 0);
-    while (doWorkers[0]() == ThreadWorkState::More) {}
+    while (doWorkers[0]() == ThreadWorkState::More) {
+    }
     return;
   }
   // run in parallel on threads
@@ -187,9 +199,7 @@ void ThreadPool::work(std::vector<std::function<ThreadWorkState ()>>& doWorkers)
   DEBUG_POOL("work() is done\n");
 }
 
-size_t ThreadPool::size() {
-  return std::max(size_t(1), threads.size());
-}
+size_t ThreadPool::size() { return std::max(size_t(1), threads.size()); }
 
 bool ThreadPool::isRunning() {
   DEBUG_POOL("check if running\n");
@@ -216,4 +226,3 @@ bool ThreadPool::areThreadsReady() {
 }
 
 } // namespace wasm
-
diff --git a/src/support/threads.h b/src/support/threads.h
index e76783ebb..8cfa79c87 100644
--- a/src/support/threads.h
+++ b/src/support/threads.h
@@ -33,10 +33,7 @@ namespace wasm {
 
 // The work state of a helper thread - is there more to do,
 // or are we finished for now.
-enum class ThreadWorkState {
-  More,
-  Finished
-};
+enum class ThreadWorkState { More, Finished };
 
 class ThreadPool;
 
@@ -52,7 +49,7 @@ class Thread {
   std::mutex mutex;
   std::condition_variable condition;
   bool done = false;
-  std::function<ThreadWorkState ()> doWork = nullptr;
+  std::function<ThreadWorkState()> doWork = nullptr;
 
 public:
   Thread(ThreadPool* parent);
@@ -60,10 +57,10 @@ public:
 
   // Start to do work, calling doWork() until
   // it returns false.
-  void work(std::function<ThreadWorkState ()> doWork);
+  void work(std::function<ThreadWorkState()> doWork);
 
 private:
-  static void mainLoop(void *self);
+  static void mainLoop(void* self);
 };
 
 //
@@ -100,7 +97,7 @@ public:
   // getTask() (in a thread-safe manner) to get tasks, and
   // sends them to workers to be executed. This method
   // blocks until all tasks are complete.
-  void work(std::vector<std::function<ThreadWorkState ()>>& doWorkers);
+  void work(std::vector<std::function<ThreadWorkState()>>& doWorkers);
 
   size_t size();
 
@@ -123,9 +120,7 @@ class OnlyOnce {
   std::atomic<int> created;
 
 public:
-  OnlyOnce() {
-    created.store(0);
-  }
+  OnlyOnce() { created.store(0); }
 
   void verify() {
     auto before = created.fetch_add(1);
@@ -135,4 +130,4 @@ public:
 
 } // namespace wasm
 
-#endif  // wasm_support_threads_h
+#endif // wasm_support_threads_h
diff --git a/src/support/timing.h b/src/support/timing.h
index a8de8de04..0b0430e24 100644
--- a/src/support/timing.h
+++ b/src/support/timing.h
@@ -33,23 +33,19 @@ class Timer {
 public:
   Timer(std::string name = "") : name(name) {}
 
-  void start() {
-    startTime = std::chrono::steady_clock::now();
-  }
+  void start() { startTime = std::chrono::steady_clock::now(); }
 
   void stop() {
-    total += std::chrono::duration<double>(std::chrono::steady_clock::now() - startTime).count();
+    total += std::chrono::duration<double>(std::chrono::steady_clock::now() -
+                                           startTime)
+               .count();
   }
 
-  double getTotal() {
-    return total;
-  }
+  double getTotal() { return total; }
 
-  void dump() {
-    std::cerr << "<Timer " << name << ": " << getTotal() << ">\n";
-  }
+  void dump() { std::cerr << "<Timer " << name << ": " << getTotal() << ">\n"; }
 };
 
 } // namespace wasm
 
-#endif  // wasm_support_timing_h
+#endif // wasm_support_timing_h
diff --git a/src/support/unique_deferring_queue.h b/src/support/unique_deferring_queue.h
index eb024e5b8..ad8f3967d 100644
--- a/src/support/unique_deferring_queue.h
+++ b/src/support/unique_deferring_queue.h
@@ -28,8 +28,7 @@
 
 namespace wasm {
 
-template<typename T>
-struct UniqueDeferredQueue {
+template<typename T> struct UniqueDeferredQueue {
   // implemented as an internal queue, plus a map
   // that says how many times an element appears. we
   // can then skip non-final appearances. this lets us
diff --git a/src/support/utilities.h b/src/support/utilities.h
index 07a163ef9..71d8ce2e0 100644
--- a/src/support/utilities.h
+++ b/src/support/utilities.h
@@ -22,8 +22,8 @@
 #include <cassert>
 #include <cstdint>
 #include <cstring>
-#include <memory>
 #include <iostream>
+#include <memory>
 #include <type_traits>
 
 #include "support/bits.h"
@@ -53,19 +53,15 @@ inline size_t alignAddr(size_t address, size_t alignment) {
 }
 
 template<typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args&&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+std::unique_ptr<T> make_unique(Args&&... args) {
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
 // For fatal errors which could arise from input (i.e. not assertion failures)
 class Fatal {
- public:
-  Fatal() {
-    std::cerr << "Fatal: ";
-  }
-  template<typename T>
-  Fatal &operator<<(T arg) {
+public:
+  Fatal() { std::cerr << "Fatal: "; }
+  template<typename T> Fatal& operator<<(T arg) {
     std::cerr << arg;
     return *this;
   }
@@ -78,7 +74,6 @@ class Fatal {
   }
 };
 
+} // namespace wasm
 
-}  // namespace wasm
-
-#endif   // wasm_support_utilities_h
+#endif // wasm_support_utilities_h