formatting

Author: stevenfontanella

src/ir/runtime-memory.cpp

@@ -20,7 +20,8 @@
 
 namespace wasm {
 
-RuntimeMemory::RuntimeMemory(Memory memory, ExternalInterface* externalInterface)
+RuntimeMemory::RuntimeMemory(Memory memory,
+                             ExternalInterface* externalInterface)
   : externalInterface(externalInterface), memoryDefinition(std::move(memory)) {}
 
 namespace {
@@ -212,9 +213,9 @@ void RealRuntimeMemory::store(Address addr,
     case Type::f32: {
       switch (byteCount) {
         case 2:
-          set<uint16_t>(final,
-                        fp16_ieee_from_fp32_value(
-                          bit_cast<float>(value.reinterpreti32())));
+          set<uint16_t>(
+            final,
+            fp16_ieee_from_fp32_value(bit_cast<float>(value.reinterpreti32())));
           break;
         case 4:
           set<int32_t>(final, value.reinterpreti32());
@@ -271,8 +272,8 @@ void RealRuntimeMemory::copy(Address dest,
                              Address byteCount,
                              const RuntimeMemory* srcMemory) {
   Address finalDest = getFinalAddress(*this, dest, 0, byteCount, size());
-  Address finalSrc = getFinalAddress(
-    *srcMemory, src, 0, byteCount, srcMemory->size());
+  Address finalSrc =
+    getFinalAddress(*srcMemory, src, 0, byteCount, srcMemory->size());
   const std::vector<uint8_t>* srcBuffer = srcMemory->getBuffer();
   if (!srcBuffer) {
     // If it's not a memory with a direct buffer, we might need another way to
@@ -299,7 +300,8 @@ void RealRuntimeMemory::resize(size_t newSize) {
   size_t newAllocatedSize = std::max(minSize, newSize);
   if (newAllocatedSize > oldAllocatedSize) {
     memory.resize(newAllocatedSize);
-    std::memset(&memory[oldAllocatedSize], 0, newAllocatedSize - oldAllocatedSize);
+    std::memset(
+      &memory[oldAllocatedSize], 0, newAllocatedSize - oldAllocatedSize);
   }
   if (newSize < oldAllocatedSize && newSize < minSize) {
     std::memset(&memory[newSize], 0, minSize - newSize);
@@ -345,6 +347,7 @@ template void RealRuntimeMemory::set<uint32_t>(size_t, uint32_t);
 template void RealRuntimeMemory::set<int64_t>(size_t, int64_t);
 template void RealRuntimeMemory::set<uint64_t>(size_t, uint64_t);
 template void
-RealRuntimeMemory::set<std::array<uint8_t, 16>>(size_t, std::array<uint8_t, 16>);
+RealRuntimeMemory::set<std::array<uint8_t, 16>>(size_t,
+                                                std::array<uint8_t, 16>);
 
 } // namespace wasm

src/ir/runtime-memory.h

@@ -50,11 +50,15 @@ class RuntimeMemory {
 
   virtual Address size() const = 0;
 
-  virtual void
-  init(Address dest, Address src, Address byteCount, const DataSegment* data) = 0;
+  virtual void init(Address dest,
+                    Address src,
+                    Address byteCount,
+                    const DataSegment* data) = 0;
 
-  virtual void
-  copy(Address dest, Address src, Address byteCount, const RuntimeMemory* srcMemory) = 0;
+  virtual void copy(Address dest,
+                    Address src,
+                    Address byteCount,
+                    const RuntimeMemory* srcMemory) = 0;
 
   virtual void fill(Address dest, uint8_t value, Address byteCount) = 0;
 
@@ -92,11 +96,15 @@ class RealRuntimeMemory : public RuntimeMemory {
 
   Address size() const override;
 
-  void
-  init(Address dest, Address src, Address byteCount, const DataSegment* data) override;
+  void init(Address dest,
+            Address src,
+            Address byteCount,
+            const DataSegment* data) override;
 
-  void
-  copy(Address dest, Address src, Address byteCount, const RuntimeMemory* srcMemory) override;
+  void copy(Address dest,
+            Address src,
+            Address byteCount,
+            const RuntimeMemory* srcMemory) override;
 
   void fill(Address dest, uint8_t value, Address byteCount) override;
 

src/tools/wasm-ctor-eval.cpp

@@ -197,7 +197,8 @@ class CtorEvalRuntimeMemory : public RealRuntimeMemory {
                bool signed_) const override {
     const_cast<CtorEvalRuntimeMemory*>(this)->ensureCapacity(addr + offset +
                                                             byteCount);
-    return RealRuntimeMemory::load(addr, offset, byteCount, order, type, signed_);
+    return RealRuntimeMemory::load(
+      addr, offset, byteCount, order, type, signed_);
   }
 
   void store(Address addr,
@@ -242,7 +243,8 @@ class EvallingModuleRunner : public ModuleRunnerBase<EvallingModuleRunner> {
             [this](Name name, Type type) { return makeFuncData(name, type); });
         },
         [](Memory memory, ExternalInterface* externalInterface) {
-          return std::make_unique<CtorEvalRuntimeMemory>(memory, externalInterface);
+          return std::make_unique<CtorEvalRuntimeMemory>(memory,
+                                                         externalInterface);
         }) {}
 
   Flow visitGlobalGet(GlobalGet* curr) {

src/wasm-interpreter.h

@@ -3010,7 +3010,8 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
   std::unordered_map<Name, RuntimeMemory*> allMemories;
 
   using CreateTableFunc = std::unique_ptr<RuntimeTable>(Literal, Table);
-  using CreateMemoryFunc = std::unique_ptr<RuntimeMemory>(Memory, ExternalInterface*);
+  using CreateMemoryFunc = std::unique_ptr<RuntimeMemory>(Memory,
+                                                          ExternalInterface*);
 
   ModuleRunnerBase(
     Module& wasm,
@@ -3030,13 +3031,13 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
               [](Literal initial, Table t) -> std::unique_ptr<RuntimeTable> {
                 return std::make_unique<RealRuntimeTable>(initial, t);
               })),
-      createMemory(
-        createMemory != nullptr
-          ? std::move(createMemory)
-          : static_cast<std::function<CreateMemoryFunc>>(
-              [externalInterface](Memory m, ExternalInterface* ei) -> std::unique_ptr<RuntimeMemory> {
-                return std::make_unique<RealRuntimeMemory>(m, ei);
-              })) {
+      createMemory(createMemory != nullptr
+                     ? std::move(createMemory)
+                     : static_cast<std::function<CreateMemoryFunc>>(
+                         [externalInterface](Memory m, ExternalInterface* ei)
+                           -> std::unique_ptr<RuntimeMemory> {
+                           return std::make_unique<RealRuntimeMemory>(m, ei);
+                         })) {
     // Set up a single shared CurrContinuations for all these linked instances,
     // reusing one if it exists.
     std::shared_ptr<ContinuationStore> shared;
@@ -3442,8 +3443,8 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
         // parsing/validation checked this already.
         assert(inserted && "Unexpected repeated memory name");
       } else {
-        auto& runtimeMemory =
-          definedMemories.emplace_back(createMemory(*memory, externalInterface));
+        auto& runtimeMemory = definedMemories.emplace_back(
+          createMemory(*memory, externalInterface));
         [[maybe_unused]] auto [_, inserted] =
           allMemories.try_emplace(memory->name, runtimeMemory.get());
         assert(inserted && "Unexpected repeated memory name");