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

1 files changed, 131 insertions, 122 deletions

diff --git a/src/ir/memory-utils.h b/src/ir/memory-utils.h
index fbf1f646c..c1edc8ce9 100644
--- a/src/ir/memory-utils.h
+++ b/src/ir/memory-utils.h
@@ -21,153 +21,162 @@
 #include <vector>
 
 #include "literal.h"
-#include "wasm.h"
 #include "wasm-binary.h"
+#include "wasm.h"
 
 namespace wasm {
 
 namespace MemoryUtils {
-  // flattens memory into a single data segment. returns true if successful
-  inline bool flatten(Memory& memory) {
-    if (memory.segments.size() == 0) return true;
-    std::vector<char> data;
-    for (auto& segment : memory.segments) {
-      if (segment.isPassive) {
-        return false;
-      }
-      auto* offset = segment.offset->dynCast<Const>();
-      if (!offset) return false;
-    }
-    for (auto& segment : memory.segments) {
-      auto* offset = segment.offset->dynCast<Const>();
-      Index start = offset->value.getInteger();
-      Index end = start + segment.data.size();
-      if (end > data.size()) {
-        data.resize(end);
-      }
-      std::copy(segment.data.begin(), segment.data.end(), data.begin() + start);
-    }
-    memory.segments.resize(1);
-    memory.segments[0].offset->cast<Const>()->value = Literal(int32_t(0));
-    memory.segments[0].data.swap(data);
+// flattens memory into a single data segment. returns true if successful
+inline bool flatten(Memory& memory) {
+  if (memory.segments.size() == 0)
     return true;
+  std::vector<char> data;
+  for (auto& segment : memory.segments) {
+    if (segment.isPassive) {
+      return false;
+    }
+    auto* offset = segment.offset->dynCast<Const>();
+    if (!offset)
+      return false;
   }
-
-  // Ensures that the memory exists (of minimal size).
-  inline void ensureExists(Memory& memory) {
-    if (!memory.exists) {
-      memory.exists = true;
-      memory.initial = memory.max = 1;
+  for (auto& segment : memory.segments) {
+    auto* offset = segment.offset->dynCast<Const>();
+    Index start = offset->value.getInteger();
+    Index end = start + segment.data.size();
+    if (end > data.size()) {
+      data.resize(end);
     }
+    std::copy(segment.data.begin(), segment.data.end(), data.begin() + start);
+  }
+  memory.segments.resize(1);
+  memory.segments[0].offset->cast<Const>()->value = Literal(int32_t(0));
+  memory.segments[0].data.swap(data);
+  return true;
+}
+
+// Ensures that the memory exists (of minimal size).
+inline void ensureExists(Memory& memory) {
+  if (!memory.exists) {
+    memory.exists = true;
+    memory.initial = memory.max = 1;
   }
+}
 
-  // Try to merge segments until they fit into web limitations.
-  // Return true if successful.
-  inline bool ensureLimitedSegments(Module& module) {
-    Memory& memory = module.memory;
-    if (memory.segments.size() <= WebLimitations::MaxDataSegments) {
-      return true;
-    }
+// Try to merge segments until they fit into web limitations.
+// Return true if successful.
+inline bool ensureLimitedSegments(Module& module) {
+  Memory& memory = module.memory;
+  if (memory.segments.size() <= WebLimitations::MaxDataSegments) {
+    return true;
+  }
 
-    // Conservatively refuse to change segments if there might be memory.init
-    // and data.drop instructions.
-    if (module.features.hasBulkMemory()) {
-      return false;
-    }
+  // Conservatively refuse to change segments if there might be memory.init
+  // and data.drop instructions.
+  if (module.features.hasBulkMemory()) {
+    return false;
+  }
 
-    auto isEmpty = [](Memory::Segment& segment) {
-      return segment.data.size() == 0;
-    };
-
-    auto isConstantOffset = [](Memory::Segment& segment) {
-      return segment.offset && segment.offset->is<Const>();
-    };
-
-    Index numConstant = 0,
-           numDynamic = 0;
-    bool hasPassiveSegments = false;
-    for (auto& segment : memory.segments) {
-      if (!isEmpty(segment)) {
-        if (isConstantOffset(segment)) {
-          numConstant++;
-        } else {
-          numDynamic++;
-        }
+  auto isEmpty = [](Memory::Segment& segment) {
+    return segment.data.size() == 0;
+  };
+
+  auto isConstantOffset = [](Memory::Segment& segment) {
+    return segment.offset && segment.offset->is<Const>();
+  };
+
+  Index numConstant = 0, numDynamic = 0;
+  bool hasPassiveSegments = false;
+  for (auto& segment : memory.segments) {
+    if (!isEmpty(segment)) {
+      if (isConstantOffset(segment)) {
+        numConstant++;
+      } else {
+        numDynamic++;
       }
-      hasPassiveSegments |= segment.isPassive;
     }
+    hasPassiveSegments |= segment.isPassive;
+  }
 
-    if (hasPassiveSegments) {
-      return false;
-    }
+  if (hasPassiveSegments) {
+    return false;
+  }
 
-    // check if we have too many dynamic data segments, which we can do nothing about
-    auto num = numConstant + numDynamic;
-    if (numDynamic + 1 >= WebLimitations::MaxDataSegments) {
-      return false;
-    }
+  // check if we have too many dynamic data segments, which we can do nothing
+  // about
+  auto num = numConstant + numDynamic;
+  if (numDynamic + 1 >= WebLimitations::MaxDataSegments) {
+    return false;
+  }
 
-    // we'll merge constant segments if we must
-    if (numConstant + numDynamic >= WebLimitations::MaxDataSegments) {
-      numConstant = WebLimitations::MaxDataSegments - numDynamic - 1;
-      num = numConstant + numDynamic;
-      assert(num == WebLimitations::MaxDataSegments - 1);
-    }
+  // we'll merge constant segments if we must
+  if (numConstant + numDynamic >= WebLimitations::MaxDataSegments) {
+    numConstant = WebLimitations::MaxDataSegments - numDynamic - 1;
+    num = numConstant + numDynamic;
+    assert(num == WebLimitations::MaxDataSegments - 1);
+  }
+
+  std::vector<Memory::Segment> mergedSegments;
+  mergedSegments.reserve(WebLimitations::MaxDataSegments);
 
-    std::vector<Memory::Segment> mergedSegments;
-    mergedSegments.reserve(WebLimitations::MaxDataSegments);
+  // drop empty segments and pass through dynamic-offset segments
+  for (auto& segment : memory.segments) {
+    if (isEmpty(segment))
+      continue;
+    if (isConstantOffset(segment))
+      continue;
+    mergedSegments.push_back(segment);
+  }
 
-    // drop empty segments and pass through dynamic-offset segments
-    for (auto& segment : memory.segments) {
-      if (isEmpty(segment)) continue;
-      if (isConstantOffset(segment)) continue;
+  // from here on, we concern ourselves with non-empty constant-offset
+  // segments, the ones which we may need to merge
+  auto isRelevant = [&](Memory::Segment& segment) {
+    return !isEmpty(segment) && isConstantOffset(segment);
+  };
+  for (Index i = 0; i < memory.segments.size(); i++) {
+    auto& segment = memory.segments[i];
+    if (!isRelevant(segment))
+      continue;
+    if (mergedSegments.size() + 2 < WebLimitations::MaxDataSegments) {
       mergedSegments.push_back(segment);
+      continue;
     }
-
-    // from here on, we concern ourselves with non-empty constant-offset
-    // segments, the ones which we may need to merge
-    auto isRelevant = [&](Memory::Segment& segment) {
-      return !isEmpty(segment) && isConstantOffset(segment);
-    };
-    for (Index i = 0; i < memory.segments.size(); i++) {
-      auto& segment = memory.segments[i];
-      if (!isRelevant(segment)) continue;
-      if (mergedSegments.size() + 2 < WebLimitations::MaxDataSegments) {
-        mergedSegments.push_back(segment);
+    // we can emit only one more segment! merge everything into one
+    // start the combined segment at the bottom of them all
+    auto start = segment.offset->cast<Const>()->value.getInteger();
+    for (Index j = i + 1; j < memory.segments.size(); j++) {
+      auto& segment = memory.segments[j];
+      if (!isRelevant(segment))
         continue;
+      auto offset = segment.offset->cast<Const>()->value.getInteger();
+      start = std::min(start, offset);
+    }
+    // create the segment and add in all the data
+    auto* c = module.allocator.alloc<Const>();
+    c->value = Literal(int32_t(start));
+    c->type = i32;
+
+    Memory::Segment combined(c);
+    for (Index j = i; j < memory.segments.size(); j++) {
+      auto& segment = memory.segments[j];
+      if (!isRelevant(segment))
+        continue;
+      auto offset = segment.offset->cast<Const>()->value.getInteger();
+      auto needed = offset + segment.data.size() - start;
+      if (combined.data.size() < needed) {
+        combined.data.resize(needed);
       }
-      // we can emit only one more segment! merge everything into one
-      // start the combined segment at the bottom of them all
-      auto start = segment.offset->cast<Const>()->value.getInteger();
-      for (Index j = i + 1; j < memory.segments.size(); j++) {
-        auto& segment = memory.segments[j];
-        if (!isRelevant(segment)) continue;
-        auto offset = segment.offset->cast<Const>()->value.getInteger();
-        start = std::min(start, offset);
-      }
-      // create the segment and add in all the data
-      auto* c = module.allocator.alloc<Const>();
-      c->value = Literal(int32_t(start));
-      c->type = i32;
-
-      Memory::Segment combined(c);
-      for (Index j = i; j < memory.segments.size(); j++) {
-        auto& segment = memory.segments[j];
-        if (!isRelevant(segment)) continue;
-        auto offset = segment.offset->cast<Const>()->value.getInteger();
-        auto needed = offset + segment.data.size() - start;
-        if (combined.data.size() < needed) {
-          combined.data.resize(needed);
-        }
-        std::copy(segment.data.begin(), segment.data.end(), combined.data.begin() + (offset - start));
-      }
-      mergedSegments.push_back(combined);
-      break;
+      std::copy(segment.data.begin(),
+                segment.data.end(),
+                combined.data.begin() + (offset - start));
     }
-
-    memory.segments.swap(mergedSegments);
-    return true;
+    mergedSegments.push_back(combined);
+    break;
   }
+
+  memory.segments.swap(mergedSegments);
+  return true;
+}
 } // namespace MemoryUtils
 
 } // namespace wasm