Fix

Author: Changqing-JING

CMakeLists.txt

@@ -4,6 +4,7 @@ enable_testing()
 
 option(WARPO_RELEASE "build for release" OFF)
 option(WARPO_SANITIZE "enable address sanitizer" OFF)
+option(WARPO_ENABLE_PERF "enable frame pointer for perf profiling" OFF)
 option(ENABLE_CLANG_TIDY "Enable clang-tidy static analysis" OFF)
 option(ENABLE_WERROR "Enable warnings as errors" OFF)
 
@@ -80,6 +81,10 @@ else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-warning-option")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
 
+  if(WARPO_ENABLE_PERF)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
+  endif()
+
   if(WARPO_SANITIZE)
     add_compile_options(-fsanitize=address)
     add_link_options(-fsanitize=address)

passes/ExtractMostFrequentlyUsedGlobals.cpp

@@ -12,8 +12,10 @@
 #include <atomic>
 #include <cassert>
 #include <fmt/format.h>
-#include <map>
 #include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 
 #include "ExtractMostFrequentlyUsedGlobals.hpp"
 #include "support/index.h"
@@ -28,7 +30,7 @@ namespace warpo::passes {
 
 namespace {
 
-using Counter = std::map<wasm::Name, std::atomic<wasm::Index>>;
+using Counter = std::unordered_map<wasm::Name, std::atomic<wasm::Index>>;
 struct Scanner : public wasm::WalkerPass<wasm::PostWalker<Scanner>> {
   explicit Scanner(Counter &counter) : counter_(counter) {}
 
@@ -72,17 +74,20 @@ static Counter createCounter(std::vector<std::unique_ptr<wasm::Global>> const &g
 }
 
 static wasm::Name findMostFrequentlyUsed(Counter const &counter) {
-  wasm::Name maxGlobalName;
-  wasm::Index maxCount = 0;
+  std::vector<std::pair<wasm::Name, wasm::Index>> sorted;
+  sorted.reserve(counter.size());
   for (auto const &[name, count] : counter) {
     if (support::isDebug(PASS_NAME))
       fmt::println("[" PASS_NAME "] '{}' used {} times", name.str, count.load());
-    if (count.load() >= maxCount) {
-      maxCount = count.load();
-      maxGlobalName = name;
-    }
+    sorted.emplace_back(name, count.load());
   }
-  return maxGlobalName;
+  // Sort by count descending, then by name ascending to break ties deterministically.
+  std::sort(sorted.begin(), sorted.end(), [](auto const &a, auto const &b) {
+    if (a.second != b.second)
+      return a.second > b.second;
+    return a.first < b.first;
+  });
+  return sorted.front().first;
 }
 
 static void extractGlobal(wasm::Module &m, wasm::Name const name) {

passes/GC/CollectLeafFunction.cpp

@@ -2,7 +2,8 @@
 // Copyright (C) 2025 wasm-ecosystem
 // SPDX-License-Identifier: Apache-2.0
 
-#include <set>
+#include <unordered_map>
+#include <unordered_set>
 
 #include "CollectLeafFunction.hpp"
 #include "GCInfo.hpp"
@@ -17,15 +18,15 @@ namespace warpo::passes::gc {
 
 static LeafFunc collectLeafFunctions(const CallGraph &cg) {
   LeafFunc leaf{};
-  std::map<wasm::Name, std::set<wasm::Name>> reservedCallGraph{};
+  std::unordered_map<wasm::Name, std::unordered_set<wasm::Name>> reservedCallGraph{};
 
   for (auto const &[caller, callees] : cg) {
     leaf.insert(caller);
     for (wasm::Name const &callee : callees) {
-      reservedCallGraph.try_emplace(callee, std::set<wasm::Name>{}).first->second.insert(caller);
+      reservedCallGraph.try_emplace(callee, std::unordered_set<wasm::Name>{}).first->second.insert(caller);
     }
   }
-  std::set<wasm::Name> workList{FnITCMSNew, FnITCMSCollect, FnTCMSNew, FnTCMSCollect};
+  std::unordered_set<wasm::Name> workList{FnITCMSNew, FnITCMSCollect, FnTCMSNew, FnTCMSCollect};
   while (!workList.empty()) {
     auto it = workList.begin();
     if (leaf.erase(*it) == 1) {
@@ -70,7 +71,7 @@ TEST(GCLeafFunctionTest, LeafFunction) {
   CG["parent_1"] = {"leaf"};
   CG["parent_poison"] = {"leaf", FnITCMSNew};
 
-  std::set<wasm::Name> const leaf = collectLeafFunctions(CG);
+  LeafFunc const leaf = collectLeafFunctions(CG);
 
   EXPECT_THAT(leaf, Contains("leaf"));
   EXPECT_THAT(leaf, Contains("parent_1"));

passes/GC/CollectLeafFunction.hpp

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <memory>
-#include <set>
+#include <unordered_set>
 
 #include "../helper/BuildCallGraph.hpp"
 #include "pass.h"
@@ -14,7 +14,7 @@
 
 namespace warpo::passes::gc {
 
-struct LeafFunc : public std::set<wasm::Name> {};
+struct LeafFunc : public std::unordered_set<wasm::Name> {};
 /// @brief collect GC leaf functions, i.e., functions that do not call __new / __collect function.
 struct LeafFunctionCollector : public wasm::Pass {
   std::shared_ptr<CallGraph const> const cg_;

passes/InlinedDecoratorLower.cpp

@@ -40,8 +40,8 @@
 #include <ir/module-utils.h>
 #include <memory>
 #include <passes/pass-utils.h>
-#include <set>
 #include <sstream>
+#include <unordered_set>
 #include <support/name.h>
 #include <utility>
 #include <vector>
@@ -103,7 +103,7 @@ ChosenActions createChosenActions(wasm::Module &m) {
 class ChosenActionsSteps {
   ChosenActions actions_;
   // functions need to be processed
-  std::set<wasm::Name> pending_;
+  std::unordered_set<wasm::Name> pending_;
 
 public:
   std::vector<ChosenActions> actionSteps_;
@@ -130,7 +130,7 @@ class ChosenActionsSteps {
       if (support::isDebug(PASS_NAME))
         for (wasm::Name const &name : pending_)
           fmt::println("[" PASS_NAME "]   pending inline '{}'", name.str);
-      std::set<wasm::Name> currentStep;
+      std::unordered_set<wasm::Name> currentStep;
       for (auto &[callerSiteFuncName, actions] : actions_) {
         if (support::isDebug(PASS_NAME)) {
           fmt::println("[" PASS_NAME "]   check '{}' whether can be processed", callerSiteFuncName.str);

passes/helper/BuildCallGraph.cpp

@@ -2,7 +2,7 @@
 // Copyright (C) 2025 wasm-ecosystem
 // SPDX-License-Identifier: Apache-2.0
 
-#include <set>
+#include <unordered_set>
 
 #include "BuildCallGraph.hpp"
 #include "support/name.h"
@@ -14,7 +14,7 @@ CallGraph CallGraphBuilder::createResults(wasm::Module &m) {
   CallGraph ret{};
   for (std::unique_ptr<wasm::Function> const &f : m.functions) {
     // we treat imported function as leaf function because in wasm-compiler, nest wasm call is not allowed.
-    ret.insert_or_assign(f->name, std::set<wasm::Name>{});
+    ret.insert_or_assign(f->name, std::unordered_set<wasm::Name>{});
   }
   return ret;
 }
@@ -23,7 +23,7 @@ void CallGraphBuilder::visitCall(wasm::Call *expr) { cg_.at(getFunction()->name)
 
 void CallGraphBuilder::visitCallIndirect(wasm::CallIndirect *expr) {
   wasm::Module *m = getModule();
-  std::set<wasm::Name> &call = cg_.at(getFunction()->name);
+  std::unordered_set<wasm::Name> &call = cg_.at(getFunction()->name);
   std::vector<wasm::Expression *> const &potentialTargets = m->getElementSegment(expr->table)->data;
   for (wasm::Expression *target : potentialTargets) {
     wasm::Name const refFunc = target->cast<wasm::RefFunc>()->func;

passes/helper/BuildCallGraph.hpp

@@ -4,17 +4,17 @@
 
 #pragma once
 
-#include <map>
 #include <memory>
-#include <set>
+#include <unordered_map>
+#include <unordered_set>
 
 #include "pass.h"
 #include "support/name.h"
 #include "wasm.h"
 
 namespace warpo::passes {
 
-using CallGraph = std::map<wasm::Name, std::set<wasm::Name>>;
+using CallGraph = std::unordered_map<wasm::Name, std::unordered_set<wasm::Name>>;
 struct CallGraphBuilder : public wasm::WalkerPass<wasm::PostWalker<CallGraphBuilder>> {
   static CallGraph createResults(wasm::Module &m);