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

Author: kripken

src/abi/js.h

@@ -17,17 +17,14 @@
 #ifndef wasm_abi_abi_h
 #define wasm_abi_abi_h
 
-#include "wasm.h"
 #include "asmjs/shared-constants.h"
+#include "wasm.h"
 
 namespace wasm {
 
 namespace ABI {
 
-enum class LegalizationLevel {
-  Full = 0,
-  Minimal = 1
-};
+enum class LegalizationLevel { Full = 0, Minimal = 1 };
 
 inline std::string getLegalizationPass(LegalizationLevel level) {
   if (level == LegalizationLevel::Full) {
@@ -39,51 +36,52 @@ inline std::string getLegalizationPass(LegalizationLevel level) {
 
 namespace wasm2js {
 
-extern cashew::IString SCRATCH_LOAD_I32,
-                       SCRATCH_STORE_I32,
-                       SCRATCH_LOAD_I64,
-                       SCRATCH_STORE_I64,
-                       SCRATCH_LOAD_F32,
-                       SCRATCH_STORE_F32,
-                       SCRATCH_LOAD_F64,
-                       SCRATCH_STORE_F64;
+extern cashew::IString SCRATCH_LOAD_I32;
+extern cashew::IString SCRATCH_STORE_I32;
+extern cashew::IString SCRATCH_LOAD_I64;
+extern cashew::IString SCRATCH_STORE_I64;
+extern cashew::IString SCRATCH_LOAD_F32;
+extern cashew::IString SCRATCH_STORE_F32;
+extern cashew::IString SCRATCH_LOAD_F64;
+extern cashew::IString SCRATCH_STORE_F64;
 
 // The wasm2js scratch memory helpers let us read and write to scratch memory
 // for purposes of implementing things like reinterpret, etc.
 // The optional "specific" parameter is a specific function we want. If not
 // provided, we create them all.
-inline void ensureScratchMemoryHelpers(Module* wasm, cashew::IString specific = cashew::IString()) {
-  auto ensureImport = [&](Name name, const std::vector<Type> params, Type result) {
-    if (wasm->getFunctionOrNull(name)) return;
-    if (specific.is() && name != specific) return;
-    auto func = make_unique<Function>();
-    func->name = name;
-    func->params = params;
-    func->result = result;
-    func->module = ENV;
-    func->base = name;
-    wasm->addFunction(std::move(func));
-  };
+inline void
+ensureScratchMemoryHelpers(Module* wasm,
+                           cashew::IString specific = cashew::IString()) {
+  auto ensureImport =
+    [&](Name name, const std::vector<Type> params, Type result) {
+      if (wasm->getFunctionOrNull(name))
+        return;
+      if (specific.is() && name != specific)
+        return;
+      auto func = make_unique<Function>();
+      func->name = name;
+      func->params = params;
+      func->result = result;
+      func->module = ENV;
+      func->base = name;
+      wasm->addFunction(std::move(func));
+    };
 
-  ensureImport(SCRATCH_LOAD_I32, { i32 }, i32);
-  ensureImport(SCRATCH_STORE_I32, { i32, i32 }, none);
+  ensureImport(SCRATCH_LOAD_I32, {i32}, i32);
+  ensureImport(SCRATCH_STORE_I32, {i32, i32}, none);
   ensureImport(SCRATCH_LOAD_I64, {}, i64);
-  ensureImport(SCRATCH_STORE_I64, { i64 }, none);
+  ensureImport(SCRATCH_STORE_I64, {i64}, none);
   ensureImport(SCRATCH_LOAD_F32, {}, f32);
-  ensureImport(SCRATCH_STORE_F32, { f32 }, none);
+  ensureImport(SCRATCH_STORE_F32, {f32}, none);
   ensureImport(SCRATCH_LOAD_F64, {}, f64);
-  ensureImport(SCRATCH_STORE_F64, { f64 }, none);
+  ensureImport(SCRATCH_STORE_F64, {f64}, none);
 }
 
 inline bool isScratchMemoryHelper(cashew::IString name) {
-  return name == SCRATCH_LOAD_I32 ||
-         name == SCRATCH_STORE_I32 ||
-         name == SCRATCH_LOAD_I64 ||
-         name == SCRATCH_STORE_I64 ||
-         name == SCRATCH_LOAD_F32 ||
-         name == SCRATCH_STORE_F32 ||
-         name == SCRATCH_LOAD_F64 ||
-         name == SCRATCH_STORE_F64;
+  return name == SCRATCH_LOAD_I32 || name == SCRATCH_STORE_I32 ||
+         name == SCRATCH_LOAD_I64 || name == SCRATCH_STORE_I64 ||
+         name == SCRATCH_LOAD_F32 || name == SCRATCH_STORE_F32 ||
+         name == SCRATCH_LOAD_F64 || name == SCRATCH_STORE_F64;
 }
 
 } // namespace wasm2js

src/abi/stack.h

@@ -17,31 +17,31 @@
 #ifndef wasm_abi_stack_h
 #define wasm_abi_stack_h
 
-#include "wasm.h"
-#include "wasm-builder.h"
-#include "shared-constants.h"
+#include "abi.h"
 #include "asmjs/shared-constants.h"
 #include "ir/find_all.h"
 #include "ir/global-utils.h"
-#include "abi.h"
+#include "shared-constants.h"
+#include "wasm-builder.h"
+#include "wasm.h"
 
 namespace wasm {
 
 namespace ABI {
 
-enum {
-  StackAlign = 16
-};
+enum { StackAlign = 16 };
 
 inline Index stackAlign(Index size) {
   return (size + StackAlign - 1) & -StackAlign;
 }
 
 // Allocate some space on the stack, and assign it to a local.
-// The local will have the same constant value in all the function, so you can just
-// local.get it anywhere there.
-inline void getStackSpace(Index local, Function* func, Index size, Module& wasm) {
-  auto* stackPointer = GlobalUtils::getGlobalInitializedToImport(wasm, ENV, "STACKTOP");
+// The local will have the same constant value in all the function, so you can
+// just local.get it anywhere there.
+inline void
+getStackSpace(Index local, Function* func, Index size, Module& wasm) {
+  auto* stackPointer =
+    GlobalUtils::getGlobalInitializedToImport(wasm, ENV, "STACKTOP");
   if (!stackPointer) {
     Fatal() << "getStackSpace: failed to find the stack pointer";
   }
@@ -50,34 +50,21 @@ inline void getStackSpace(Index local, Function* func, Index size, Module& wasm)
   // TODO: find existing stack usage, and add on top of that - carefully
   Builder builder(wasm);
   auto* block = builder.makeBlock();
-  block->list.push_back(
-    builder.makeSetLocal(
-      local,
-      builder.makeGetGlobal(stackPointer->name, PointerType)
-    )
-  );
+  block->list.push_back(builder.makeSetLocal(
+    local, builder.makeGetGlobal(stackPointer->name, PointerType)));
   // TODO: add stack max check
   Expression* added;
   if (PointerType == i32) {
-    added = builder.makeBinary(
-      AddInt32,
-      builder.makeGetLocal(local, PointerType),
-      builder.makeConst(Literal(int32_t(size)))
-    );
+    added = builder.makeBinary(AddInt32,
+                               builder.makeGetLocal(local, PointerType),
+                               builder.makeConst(Literal(int32_t(size))));
   } else {
     WASM_UNREACHABLE();
   }
-  block->list.push_back(
-    builder.makeSetGlobal(
-      stackPointer->name,
-      added
-    )
-  );
+  block->list.push_back(builder.makeSetGlobal(stackPointer->name, added));
   auto makeStackRestore = [&]() {
-    return builder.makeSetGlobal(
-      stackPointer->name,
-      builder.makeGetLocal(local, PointerType)
-    );
+    return builder.makeSetGlobal(stackPointer->name,
+                                 builder.makeGetLocal(local, PointerType));
   };
   // add stack restores to the returns
   FindAllPointers<Return> finder(func->body);
@@ -89,9 +76,8 @@ inline void getStackSpace(Index local, Function* func, Index size, Module& wasm)
       auto temp = builder.addVar(func, ret->value->type);
       block->list.push_back(builder.makeSetLocal(temp, ret->value));
       block->list.push_back(makeStackRestore());
-      block->list.push_back(builder.makeReturn(
-        builder.makeGetLocal(temp, ret->value->type)
-      ));
+      block->list.push_back(
+        builder.makeReturn(builder.makeGetLocal(temp, ret->value->type)));
       block->finalize();
       *ptr = block;
     } else {

src/abi/wasm-object.h

@@ -25,14 +25,14 @@
 namespace wasm {
 
 namespace ABI {
-  enum LinkType : unsigned {
-    WASM_STACK_POINTER  = 0x1,
-    WASM_SYMBOL_INFO    = 0x2,
-    WASM_DATA_SIZE      = 0x3,
-    WASM_DATA_ALIGNMENT = 0x4,
-    WASM_SEGMENT_INFO   = 0x5,
-    WASM_INIT_FUNCS     = 0x6,
-  };
+enum LinkType : unsigned {
+  WASM_STACK_POINTER = 0x1,
+  WASM_SYMBOL_INFO = 0x2,
+  WASM_DATA_SIZE = 0x3,
+  WASM_DATA_ALIGNMENT = 0x4,
+  WASM_SEGMENT_INFO = 0x5,
+  WASM_INIT_FUNCS = 0x6,
+};
 } // namespace ABI
 
 } // namespace wasm