Clang-format codebase (#1684)

This applies clang-format to the whole codebase.

I noticed we have .clang-format in wabt but the codebase is not very
well formatted. This kind of mass-formatting PR has fans and skeptics
because it can mess with `git blame`, but we did a similar thing in
Binaryen a few years ago (WebAssembly/binaryen#2048, which was merged in
WebAssembly/binaryen#2059) and it was not very confusing after all.
If we are ever going to format the codebase, I think it is easier to do
it in a single big PR than dozens of smaller PRs.

This is using the existing .clang-format file in this repo, which
follows the style of Chromium. If we think this does not suit the
current formatting style, we can potentially tweak .clang-format too.
For example, I noticed the current codebase puts many `case` statements
within a single line when they are short, but the current .clang-format
does not allow that.

This does not include files in src/prebuilt, because they are generated.

This also manually fixes some comment lines, because mechanically
applying clang-format to long inline comments can look weird.

I also added a clang-format check hook in the Github CI in #1683, which
I think can be less controversial, given that it only checks the diff.

---

After discussions, we ended up reverting many changes, especially
one-liner functions and switch-cases, which are too many to wrap in
`// clang-format off` and `// clang-format on`. I also considered fixing
`.clang-format` to allow those one-liners but it caused a larger churn
in other parts. So currently the codebase does not conform to
`.clang-format` 100%, but we decided it's fine.

10 files changed, 131 insertions, 116 deletions

diff --git a/src/interp/binary-reader-interp.cc b/src/interp/binary-reader-interp.cc
index 699fdd20..cf4436f6 100644
--- a/src/interp/binary-reader-interp.cc
+++ b/src/interp/binary-reader-interp.cc
@@ -911,9 +911,9 @@ Result BinaryReaderInterp::OnSimdLoadLaneExpr(Opcode opcode,
 }
 
 Result BinaryReaderInterp::OnSimdStoreLaneExpr(Opcode opcode,
-                                              Address alignment_log2,
-                                              Address offset,
-                                              uint64_t value) {
+                                               Address alignment_log2,
+                                               Address offset,
+                                               uint64_t value) {
   CHECK_RESULT(validator_.OnSimdStoreLane(GetLocation(), opcode,
                                           GetAlignment(alignment_log2), value));
   istream_.Emit(opcode, kMemoryIndex0, offset, static_cast<u8>(value));
diff --git a/src/interp/interp-inl.h b/src/interp/interp-inl.h
index 2c452f02..1237d811 100644
--- a/src/interp/interp-inl.h
+++ b/src/interp/interp-inl.h
@@ -261,7 +261,7 @@ RefPtr<T>::RefPtr(const RefPtr<U>& other)
 
 template <typename T>
 template <typename U>
-RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other){
+RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other) {
   obj_ = other.obj_;
   store_ = other.store_;
   root_index_ = store_ ? store_->CopyRoot(other.root_index_) : 0;
@@ -366,7 +366,8 @@ template <> inline bool HasType<f32>(ValueType type) { return type == ValueType:
 template <> inline bool HasType<f64>(ValueType type) { return type == ValueType::F64; }
 template <> inline bool HasType<Ref>(ValueType type) { return IsReference(type); }
 
-template <typename T> void RequireType(ValueType type) {
+template <typename T>
+void RequireType(ValueType type) {
   assert(HasType<T>(type));
 }
 
@@ -659,10 +660,8 @@ inline Memory::Ptr Memory::New(interp::Store& store, MemoryType type) {
 
 inline bool Memory::IsValidAccess(u64 offset, u64 addend, u64 size) const {
   // FIXME: make this faster.
-  return offset <= data_.size() &&
-         addend <= data_.size() &&
-         size <= data_.size() &&
-         offset + addend + size <= data_.size();
+  return offset <= data_.size() && addend <= data_.size() &&
+         size <= data_.size() && offset + addend + size <= data_.size();
 }
 
 inline bool Memory::IsValidAtomicAccess(u64 offset,
@@ -677,7 +676,8 @@ Result Memory::Load(u64 offset, u64 addend, T* out) const {
   if (!IsValidAccess(offset, addend, sizeof(T))) {
     return Result::Error;
   }
-  wabt::MemcpyEndianAware(out, data_.data(), sizeof(T), data_.size(), 0, offset + addend, sizeof(T));
+  wabt::MemcpyEndianAware(out, data_.data(), sizeof(T), data_.size(), 0,
+                          offset + addend, sizeof(T));
   return Result::Ok;
 }
 
@@ -685,7 +685,8 @@ template <typename T>
 T WABT_VECTORCALL Memory::UnsafeLoad(u64 offset, u64 addend) const {
   assert(IsValidAccess(offset, addend, sizeof(T)));
   T val;
-  wabt::MemcpyEndianAware(&val, data_.data(), sizeof(T), data_.size(), 0, offset + addend, sizeof(T));
+  wabt::MemcpyEndianAware(&val, data_.data(), sizeof(T), data_.size(), 0,
+                          offset + addend, sizeof(T));
   return val;
 }
 
@@ -694,7 +695,8 @@ Result WABT_VECTORCALL Memory::Store(u64 offset, u64 addend, T val) {
   if (!IsValidAccess(offset, addend, sizeof(T))) {
     return Result::Error;
   }
-  wabt::MemcpyEndianAware(data_.data(), &val, data_.size(), sizeof(T), offset + addend, 0, sizeof(T));
+  wabt::MemcpyEndianAware(data_.data(), &val, data_.size(), sizeof(T),
+                          offset + addend, 0, sizeof(T));
   return Result::Ok;
 }
 
@@ -703,7 +705,8 @@ Result Memory::AtomicLoad(u64 offset, u64 addend, T* out) const {
   if (!IsValidAtomicAccess(offset, addend, sizeof(T))) {
     return Result::Error;
   }
-  wabt::MemcpyEndianAware(out, data_.data(), sizeof(T), data_.size(), 0, offset + addend, sizeof(T));
+  wabt::MemcpyEndianAware(out, data_.data(), sizeof(T), data_.size(), 0,
+                          offset + addend, sizeof(T));
   return Result::Ok;
 }
 
@@ -712,7 +715,8 @@ Result Memory::AtomicStore(u64 offset, u64 addend, T val) {
   if (!IsValidAtomicAccess(offset, addend, sizeof(T))) {
     return Result::Error;
   }
-  wabt::MemcpyEndianAware(data_.data(), &val, data_.size(), sizeof(T), offset + addend, 0, sizeof(T));
+  wabt::MemcpyEndianAware(data_.data(), &val, data_.size(), sizeof(T),
+                          offset + addend, 0, sizeof(T));
   return Result::Ok;
 }
 
diff --git a/src/interp/interp-math.h b/src/interp/interp-math.h
index 25716b27..444a5ee5 100644
--- a/src/interp/interp-math.h
+++ b/src/interp/interp-math.h
@@ -211,17 +211,19 @@ inline f64 WABT_VECTORCALL FloatAbs(f64 val) {
 template <>
 inline f32 WABT_VECTORCALL FloatCopysign(f32 lhs, f32 rhs) {
   return _mm_cvtss_f32(
-    _mm_or_ps(
-      _mm_and_ps(_mm_set1_ps(lhs), _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))),
-      _mm_and_ps(_mm_set1_ps(rhs), _mm_castsi128_ps(_mm_set1_epi32(0x80000000)))));
+      _mm_or_ps(_mm_and_ps(_mm_set1_ps(lhs),
+                           _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))),
+                _mm_and_ps(_mm_set1_ps(rhs),
+                           _mm_castsi128_ps(_mm_set1_epi32(0x80000000)))));
 }
 
 template <>
 inline f64 WABT_VECTORCALL FloatCopysign(f64 lhs, f64 rhs) {
-  return _mm_cvtsd_f64(
-    _mm_or_pd(
-      _mm_and_pd(_mm_set1_pd(lhs), _mm_castsi128_pd(_mm_set1_epi64x(0x7fffffffffffffffull))),
-      _mm_and_pd(_mm_set1_pd(rhs), _mm_castsi128_pd(_mm_set1_epi64x(0x8000000000000000ull)))));
+  return _mm_cvtsd_f64(_mm_or_pd(
+      _mm_and_pd(_mm_set1_pd(lhs),
+                 _mm_castsi128_pd(_mm_set1_epi64x(0x7fffffffffffffffull))),
+      _mm_and_pd(_mm_set1_pd(rhs),
+                 _mm_castsi128_pd(_mm_set1_epi64x(0x8000000000000000ull)))));
 }
 
 #else
diff --git a/src/interp/interp-util.h b/src/interp/interp-util.h
index d05b34de..bc94abc2 100644
--- a/src/interp/interp-util.h
+++ b/src/interp/interp-util.h
@@ -47,4 +47,4 @@ void WriteCall(Stream* stream,
 }  // namespace interp
 }  // namespace wabt
 
-#endif // WABT_INTERP_UTIL_H_
+#endif  // WABT_INTERP_UTIL_H_
diff --git a/src/interp/interp-wasi.cc b/src/interp/interp-wasi.cc
index 15d71250..61b6f71d 100644
--- a/src/interp/interp-wasi.cc
+++ b/src/interp/interp-wasi.cc
@@ -92,13 +92,13 @@ typedef struct __wasi_fdstat_t {
 static_assert(sizeof(__wasi_fdstat_t) == 24, "witx calculated size");
 static_assert(alignof(__wasi_fdstat_t) == 8, "witx calculated align");
 static_assert(offsetof(__wasi_fdstat_t, fs_filetype) == 0,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_fdstat_t, fs_flags) == 2,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_fdstat_t, fs_rights_base) == 8,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_fdstat_t, fs_rights_inheriting) == 16,
-               "witx calculated offset");
+              "witx calculated offset");
 
 struct __wasi_iovec_t {
   __wasi_ptr_t buf;
@@ -141,17 +141,17 @@ static_assert(alignof(__wasi_filestat_t) == 8, "witx calculated align");
 static_assert(offsetof(__wasi_filestat_t, dev) == 0, "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, ino) == 8, "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, filetype) == 16,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, nlink) == 24,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, size) == 32,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, atim) == 40,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, mtim) == 48,
-               "witx calculated offset");
+              "witx calculated offset");
 static_assert(offsetof(__wasi_filestat_t, ctim) == 56,
-               "witx calculated offset");
+              "witx calculated offset");
 
 #define __WASI_ERRNO_SUCCESS (UINT16_C(0))
 #define __WASI_ERRNO_NOENT (UINT16_C(44))
@@ -194,8 +194,8 @@ class WasiInstance {
      *                                      __wasi_timestamp_t *time)
      */
     __wasi_timestamp_t t;
-    results[0].Set<u32>(
-        uvwasi_clock_time_get(uvwasi, params[0].Get<u32>(), params[1].Get<u64>(), &t));
+    results[0].Set<u32>(uvwasi_clock_time_get(uvwasi, params[0].Get<u32>(),
+                                              params[1].Get<u64>(), &t));
     uint32_t time_ptr = params[2].Get<u32>();
     CHECK_RESULT(writeValue<__wasi_timestamp_t>(t, time_ptr, trap));
     return Result::Ok;
@@ -231,9 +231,9 @@ class WasiInstance {
       trace_stream->Writef("path_open : %s\n", path);
     }
     uvwasi_fd_t outfd;
-    results[0].Set<u32>(
-        uvwasi_path_open(uvwasi, dirfd, dirflags, path, path_len, oflags,
-                         fs_rights_base, fs_rights_inherting, fs_flags, &outfd));
+    results[0].Set<u32>(uvwasi_path_open(
+        uvwasi, dirfd, dirflags, path, path_len, oflags, fs_rights_base,
+        fs_rights_inherting, fs_flags, &outfd));
     if (trace_stream) {
       trace_stream->Writef("path_open -> %d\n", results[0].Get<u32>());
     }
@@ -268,8 +268,8 @@ class WasiInstance {
         filestat_ptr, sizeof(__wasi_filestat_t), &filestat, trap));
     uvwasi_serdes_write_filestat_t(filestat, 0, &buf);
     if (trace_stream) {
-      trace_stream->Writef("path_filestat_get -> size=%" PRIu64 " %d\n", buf.st_size,
-                           results[0].Get<u32>());
+      trace_stream->Writef("path_filestat_get -> size=%" PRIu64 " %d\n",
+                           buf.st_size, results[0].Get<u32>());
     }
     return Result::Ok;
   }
@@ -395,8 +395,8 @@ class WasiInstance {
         filestat_ptr, sizeof(__wasi_filestat_t), &filestat, trap));
     uvwasi_serdes_write_filestat_t(filestat, 0, &buf);
     if (trace_stream) {
-      trace_stream->Writef("fd_filestat_get -> size=%" PRIu64 " %d\n", buf.st_size,
-                           results[0].Get<u32>());
+      trace_stream->Writef("fd_filestat_get -> size=%" PRIu64 " %d\n",
+                           buf.st_size, results[0].Get<u32>());
     }
     return Result::Ok;
   }
@@ -477,7 +477,8 @@ class WasiInstance {
           reinterpret_cast<const uint8_t**>(&iovs[i].buf), trap));
     }
     __wasi_ptr_t* out_addr;
-    CHECK_RESULT(getMemPtr<__wasi_ptr_t>(params[3].Get<u32>(), 1, &out_addr, trap));
+    CHECK_RESULT(
+        getMemPtr<__wasi_ptr_t>(params[3].Get<u32>(), 1, &out_addr, trap));
     results[0].Set<u32>(
         uvwasi_fd_write(uvwasi, fd, iovs.data(), iovs.size(), out_addr));
     return Result::Ok;
@@ -537,7 +538,8 @@ class WasiInstance {
     uvwasi_size_t environ_buf_size;
     uvwasi_environ_sizes_get(uvwasi, &environc, &environ_buf_size);
     CHECK_RESULT(writeValue<uint32_t>(environc, params[0].Get<u32>(), trap));
-    CHECK_RESULT(writeValue<uint32_t>(environ_buf_size, params[1].Get<u32>(), trap));
+    CHECK_RESULT(
+        writeValue<uint32_t>(environ_buf_size, params[1].Get<u32>(), trap));
     if (trace_stream) {
       trace_stream->Writef("environ_sizes_get -> %d %d\n", environc,
                            environ_buf_size);
@@ -573,7 +575,8 @@ class WasiInstance {
     uvwasi_size_t arg_buf_size;
     uvwasi_args_sizes_get(uvwasi, &argc, &arg_buf_size);
     CHECK_RESULT(writeValue<uint32_t>(argc, params[0].Get<u32>(), trap));
-    CHECK_RESULT(writeValue<uint32_t>(arg_buf_size, params[1].Get<u32>(), trap));
+    CHECK_RESULT(
+        writeValue<uint32_t>(arg_buf_size, params[1].Get<u32>(), trap));
     if (trace_stream) {
       trace_stream->Writef("args_sizes_get -> %d %d\n", argc, arg_buf_size);
     }
diff --git a/src/interp/interp-wasm-c-api.cc b/src/interp/interp-wasm-c-api.cc
index 44fe0868..14bfa83b 100644
--- a/src/interp/interp-wasm-c-api.cc
+++ b/src/interp/interp-wasm-c-api.cc
@@ -48,7 +48,7 @@ static std::unique_ptr<FileStream> s_stdout_stream;
 static ValueType ToWabtValueType(wasm_valkind_t);
 static wasm_valkind_t FromWabtValueType(ValueType);
 
-static wasm_externkind_t FromWabtExternKind(ExternKind );
+static wasm_externkind_t FromWabtExternKind(ExternKind);
 
 static ValueTypes ToWabtValueTypes(const wasm_valtype_vec_t* types);
 static void FromWabtValueTypes(const ValueTypes&, wasm_valtype_vec_t* out);
@@ -81,17 +81,17 @@ struct wasm_valtype_t {
 struct wasm_externtype_t {
   static std::unique_ptr<wasm_externtype_t> New(std::unique_ptr<ExternType>);
 
-  std::unique_ptr<wasm_externtype_t> Clone() const {
-    return New(I->Clone());
-  }
+  std::unique_ptr<wasm_externtype_t> Clone() const { return New(I->Clone()); }
 
   virtual ~wasm_externtype_t() {}
 
   wasm_externtype_t(const wasm_externtype_t& other) = delete;
-  wasm_externtype_t& operator=(const wasm_externtype_t& other)  = delete;
+  wasm_externtype_t& operator=(const wasm_externtype_t& other) = delete;
 
   template <typename T>
-  T* As() const { return cast<T>(I.get()); }
+  T* As() const {
+    return cast<T>(I.get());
+  }
 
   std::unique_ptr<ExternType> I;
 
@@ -251,7 +251,9 @@ struct wasm_ref_t {
   wasm_ref_t(RefPtr<Object> ptr) : I(ptr) {}
 
   template <typename T>
-  T* As() const { return cast<T>(I.get()); }
+  T* As() const {
+    return cast<T>(I.get());
+  }
 
   RefPtr<Object> I;
 };
@@ -285,9 +287,7 @@ struct wasm_module_t : wasm_ref_t {
     return *this;
   }
 
-  ~wasm_module_t() {
-    wasm_byte_vec_delete(&binary);
-  }
+  ~wasm_module_t() { wasm_byte_vec_delete(&binary); }
   // TODO: This is used for wasm_module_serialize/wasm_module_deserialize.
   // Currently the standard wasm binary bytes are cached here, but it would be
   // better to have a serialization of ModuleDesc instead.
diff --git a/src/interp/interp.cc b/src/interp/interp.cc
index 9b8eb4c5..bba27c9b 100644
--- a/src/interp/interp.cc
+++ b/src/interp/interp.cc
@@ -284,7 +284,7 @@ void Store::Mark(Ref ref) {
 }
 
 void Store::Mark(const RefVec& refs) {
-  for (auto&& ref: refs) {
+  for (auto&& ref : refs) {
     Mark(ref);
   }
 }
@@ -492,8 +492,7 @@ Result Table::Grow(Store& store, u32 count, Ref ref) {
 }
 
 Result Table::Fill(Store& store, u32 offset, Ref ref, u32 size) {
-  if (IsValidRange(offset, size) &&
-      store.HasValueType(ref, type_.element)) {
+  if (IsValidRange(offset, size) && store.HasValueType(ref, type_.element)) {
     std::fill(elements_.begin() + offset, elements_.begin() + offset + size,
               ref);
     return Result::Ok;
@@ -731,11 +730,11 @@ bool DataSegment::IsValidRange(u64 offset, u64 size) const {
 //// Module ////
 Module::Module(Store&, ModuleDesc desc)
     : Object(skind), desc_(std::move(desc)) {
-  for (auto&& import: desc_.imports) {
+  for (auto&& import : desc_.imports) {
     import_types_.emplace_back(import.type);
   }
 
-  for (auto&& export_: desc_.exports) {
+  for (auto&& export_ : desc_.exports) {
     export_types_.emplace_back(export_.type);
   }
 }
@@ -821,7 +820,7 @@ Instance::Ptr Instance::Instantiate(Store& store,
   }
 
   // Exports.
-  for (auto&& desc : mod->desc().exports){
+  for (auto&& desc : mod->desc().exports) {
     Ref ref;
     switch (desc.type.type->kind) {
       case ExternKind::Func:   ref = inst->funcs_[desc.index]; break;
@@ -895,12 +894,11 @@ Instance::Ptr Instance::Instantiate(Store& store,
 
         if (Failed(result)) {
           *out_trap = Trap::New(
-              store,
-              StringPrintf("out of bounds memory access: data segment is "
-                           "out of bounds: [%" PRIu64 ", %" PRIu64
-                           ") >= max value %"
-                           PRIu64, offset, offset + segment.size(),
-                           memory->ByteSize()));
+              store, StringPrintf(
+                         "out of bounds memory access: data segment is "
+                         "out of bounds: [%" PRIu64 ", %" PRIu64
+                         ") >= max value %" PRIu64,
+                         offset, offset + segment.size(), memory->ByteSize()));
           return {};
         }
       } else if (desc.mode == SegmentMode::Declared) {
@@ -950,7 +948,7 @@ void Thread::Mark(Store& store) {
   for (auto&& frame : frames_) {
     frame.Mark(store);
   }
-  for (auto index: refs_) {
+  for (auto index : refs_) {
     store.Mark(values_[index].Get<Ref>());
   }
   store.Mark(exceptions_);
@@ -1048,7 +1046,7 @@ RunResult Thread::Run(Trap::Ptr* out_trap) {
 
 RunResult Thread::Run(int num_instructions, Trap::Ptr* out_trap) {
   DefinedFunc::Ptr func{store_, frames_.back().func};
-  for (;num_instructions > 0; --num_instructions) {
+  for (; num_instructions > 0; --num_instructions) {
     auto result = StepInternal(out_trap);
     if (result != RunResult::Ok) {
       return result;
@@ -2307,8 +2305,7 @@ RunResult Thread::DoSimdShuffle(Instr instr) {
   auto lhs = Pop<S>();
   S result;
   for (u8 i = 0; i < S::lanes; ++i) {
-    result[i] =
-        sel[i] < S::lanes ? lhs[sel[i]] : rhs[sel[i] - S::lanes];
+    result[i] = sel[i] < S::lanes ? lhs[sel[i]] : rhs[sel[i] - S::lanes];
   }
   Push(result);
   return RunResult::Ok;
@@ -2378,7 +2375,7 @@ RunResult Thread::DoSimdExtaddPairwise() {
   using U = typename S::LaneType;
   for (u8 i = 0; i < S::lanes; ++i) {
     u8 laneidx = i * 2;
-    result[i] = U(val[laneidx]) + U(val[laneidx+1]);
+    result[i] = U(val[laneidx]) + U(val[laneidx + 1]);
   }
   Push(result);
   return RunResult::Ok;
@@ -2393,7 +2390,7 @@ RunResult Thread::DoSimdDot() {
   for (u8 i = 0; i < S::lanes; ++i) {
     u8 laneidx = i * 2;
     SL lo = SL(lhs[laneidx]) * SL(rhs[laneidx]);
-    SL hi = SL(lhs[laneidx+1]) * SL(rhs[laneidx+1]);
+    SL hi = SL(lhs[laneidx + 1]) * SL(rhs[laneidx + 1]);
     result[i] = Add(lo, hi);
   }
   Push(result);
@@ -2565,8 +2562,8 @@ std::string Thread::TraceSource::Pick(Index index, Instr instr) {
     }
   }
   auto type = index > num_operands
-    ? Type(ValueType::Void)
-    : instr.op.GetParamType(num_operands - index + 1);
+                  ? Type(ValueType::Void)
+                  : instr.op.GetParamType(num_operands - index + 1);
   if (type == ValueType::Void) {
     // Void should never be displayed normally; we only expect to see it when
     // the stack may have different a different type. This is likely to occur
diff --git a/src/interp/interp.h b/src/interp/interp.h
index fa108774..5c7dd8d3 100644
--- a/src/interp/interp.h
+++ b/src/interp/interp.h
@@ -44,7 +44,8 @@ class ElemSegment;
 class Module;
 class Instance;
 class Thread;
-template <typename T> class RefPtr;
+template <typename T>
+class RefPtr;
 
 using s8 = int8_t;
 using u8 = uint8_t;
@@ -63,8 +64,10 @@ using Buffer = std::vector<u8>;
 using ValueType = wabt::Type;
 using ValueTypes = std::vector<ValueType>;
 
-template <typename T> bool HasType(ValueType);
-template <typename T> void RequireType(ValueType);
+template <typename T>
+bool HasType(ValueType);
+template <typename T>
+void RequireType(ValueType);
 bool IsReference(ValueType);
 bool TypesMatch(ValueType expected, ValueType actual);
 
@@ -142,13 +145,13 @@ struct Simd {
 
   inline T& operator[](u8 idx) {
 #if WABT_BIG_ENDIAN
-    idx = (~idx) & (L-1);
+    idx = (~idx) & (L - 1);
 #endif
     return v[idx];
   }
   inline T operator[](u8 idx) const {
 #if WABT_BIG_ENDIAN
-    idx = (~idx) & (L-1);
+    idx = (~idx) & (L - 1);
 #endif
     return v[idx];
   }
@@ -416,7 +419,7 @@ struct Frame {
   void Mark(Store&);
 
   Ref func;
-  u32 values;  // Height of the value stack at this activation.
+  u32 values;      // Height of the value stack at this activation.
   u32 exceptions;  // Height of the exception stack at this activation.
   u32 offset;      // Istream offset; either the return PC, or the current PC.
 
@@ -439,8 +442,8 @@ class FreeList {
   const T& Get(Index) const;
   T& Get(Index);
 
-  Index size() const;  // 1 greater than the maximum index.
-  Index count() const; // The number of used elements.
+  Index size() const;   // 1 greater than the maximum index.
+  Index count() const;  // The number of used elements.
 
  private:
   // TODO: Optimize memory layout? We could probably store all of this
diff --git a/src/interp/istream.cc b/src/interp/istream.cc
index 301411f5..7ef27688 100644
--- a/src/interp/istream.cc
+++ b/src/interp/istream.cc
@@ -865,7 +865,7 @@ Istream::Offset Istream::Trace(Stream* stream,
       break;
 
     case InstrKind::Imm_Index_Op_N:
-      stream->Writef(" $%u\n", instr.imm_u32); // TODO param/result count?
+      stream->Writef(" $%u\n", instr.imm_u32);  // TODO param/result count?
       break;
 
     case InstrKind::Imm_Index_Index_Op_3:
@@ -899,9 +899,10 @@ Istream::Offset Istream::Trace(Stream* stream,
       break;
 
     case InstrKind::Imm_Index_Offset_Lane_Op_2:
-      stream->Writef(" $%u:%s+$%u, %s (Lane imm: $%u)\n", instr.imm_u32x2_u8.fst,
-                     source->Pick(2, instr).c_str(), instr.imm_u32x2_u8.snd,
-                     source->Pick(1, instr).c_str(), instr.imm_u32x2_u8.idx);
+      stream->Writef(" $%u:%s+$%u, %s (Lane imm: $%u)\n",
+                     instr.imm_u32x2_u8.fst, source->Pick(2, instr).c_str(),
+                     instr.imm_u32x2_u8.snd, source->Pick(1, instr).c_str(),
+                     instr.imm_u32x2_u8.idx);
       break;
 
     case InstrKind::Imm_I32_Op_0:
diff --git a/src/interp/istream.h b/src/interp/istream.h
index c8685507..d671e14b 100644
--- a/src/interp/istream.h
+++ b/src/interp/istream.h
@@ -18,8 +18,8 @@
 #define WABT_INTERP_ISTREAM_H_
 
 #include <cstdint>
-#include <vector>
 #include <string>
+#include <vector>
 
 #include "src/common.h"
 #include "src/opcode.h"
@@ -43,32 +43,32 @@ using ValueType = wabt::Type;
 // simplify instruction decoding, disassembling, and tracing. There is an
 // example of an instruction that uses this encoding on the right.
 enum class InstrKind {
-  Imm_0_Op_0,             // Nop
-  Imm_0_Op_1,             // i32.eqz
-  Imm_0_Op_2,             // i32.add
-  Imm_0_Op_3,             // select
-  Imm_Jump_Op_0,          // br
-  Imm_Jump_Op_1,          // br_if
-  Imm_Index_Op_0,         // global.get
-  Imm_Index_Op_1,         // global.set
-  Imm_Index_Op_2,         // table.set
-  Imm_Index_Op_3,         // memory.fill
-  Imm_Index_Op_N,         // call
-  Imm_Index_Index_Op_3,   // memory.init
-  Imm_Index_Index_Op_N,   // call_indirect
-  Imm_Index_Offset_Op_1,  // i32.load
-  Imm_Index_Offset_Op_2,  // i32.store
-  Imm_Index_Offset_Op_3,  // i32.atomic.rmw.cmpxchg
-  Imm_Index_Offset_Lane_Op_2, // v128.load8_lane
-  Imm_I32_Op_0,           // i32.const
-  Imm_I64_Op_0,           // i64.const
-  Imm_F32_Op_0,           // f32.const
-  Imm_F64_Op_0,           // f64.const
-  Imm_I32_I32_Op_0,       // drop_keep
-  Imm_I8_Op_1,            // i32x4.extract_lane
-  Imm_I8_Op_2,            // i32x4.replace_lane
-  Imm_V128_Op_0,          // v128.const
-  Imm_V128_Op_2,          // i8x16.shuffle
+  Imm_0_Op_0,                  // Nop
+  Imm_0_Op_1,                  // i32.eqz
+  Imm_0_Op_2,                  // i32.add
+  Imm_0_Op_3,                  // select
+  Imm_Jump_Op_0,               // br
+  Imm_Jump_Op_1,               // br_if
+  Imm_Index_Op_0,              // global.get
+  Imm_Index_Op_1,              // global.set
+  Imm_Index_Op_2,              // table.set
+  Imm_Index_Op_3,              // memory.fill
+  Imm_Index_Op_N,              // call
+  Imm_Index_Index_Op_3,        // memory.init
+  Imm_Index_Index_Op_N,        // call_indirect
+  Imm_Index_Offset_Op_1,       // i32.load
+  Imm_Index_Offset_Op_2,       // i32.store
+  Imm_Index_Offset_Op_3,       // i32.atomic.rmw.cmpxchg
+  Imm_Index_Offset_Lane_Op_2,  // v128.load8_lane
+  Imm_I32_Op_0,                // i32.const
+  Imm_I64_Op_0,                // i64.const
+  Imm_F32_Op_0,                // f32.const
+  Imm_F64_Op_0,                // f64.const
+  Imm_I32_I32_Op_0,            // drop_keep
+  Imm_I8_Op_1,                 // i32x4.extract_lane
+  Imm_I8_Op_2,                 // i32x4.replace_lane
+  Imm_V128_Op_0,               // v128.const
+  Imm_V128_Op_2,               // i8x16.shuffle
 };
 
 struct Instr {
@@ -81,8 +81,13 @@ struct Instr {
     u64 imm_u64;
     f64 imm_f64;
     v128 imm_v128;
-    struct { u32 fst, snd; } imm_u32x2;
-    struct { u32 fst, snd; u8 idx; } imm_u32x2_u8;
+    struct {
+      u32 fst, snd;
+    } imm_u32x2;
+    struct {
+      u32 fst, snd;
+      u8 idx;
+    } imm_u32x2_u8;
   };
 };
 
@@ -142,7 +147,7 @@ class Istream {
 
   Offset Trace(Stream*, Offset, TraceSource*) const;
 
-private:
+ private:
   template <typename T>
   void WABT_VECTORCALL EmitAt(Offset, T val);
   template <typename T>