Issue 5063 - [emscripten] Make FilterNotifier calls more efficient

compiled/bindings.ipp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 25 matching lines @@
 
 namespace bindings_internal
 {
   typedef void* TYPEID;
 
   enum class TypeCategory
   {
     UNKNOWN,
     VOID,
     INT,
+    INT64,
     FLOAT,
+    DOUBLE,
     DEPENDENT_STRING,
     OWNED_STRING,
     STRING_REF,
     CLASS_PTR
   };
 
   template<typename T>
   struct TypeInfo
   {
     /*
      * Since TypeInfo is a templated type, in practice the compiler will define
      * a new type for each possible template parameter value. We use that fact
      * to generate type identifiers: each of these TypeInfo types has a
      * different s_typeIDHelper member, so we use a pointer to that static
      * variable as a type identifier - it will be different for each template
      * parameter.
      */
     static char s_typeIDHelper;
     constexpr operator TYPEID() const
     {
       return &s_typeIDHelper;
     }
 
     constexpr operator TypeCategory() const
     {
       if (std::is_void<T>())
         return TypeCategory::VOID;
 
+      if (std::is_same<T, uint64_t>())
+        return TypeCategory::INT64;
+
       if (std::is_integral<T>() || std::is_enum<T>())
         return TypeCategory::INT;
 
-      if (std::is_floating_point<T>())
+      if (std::is_same<T, float>())
         return TypeCategory::FLOAT;
+
+      if (std::is_same<T, double>())
+        return TypeCategory::DOUBLE;
 
       if (std::is_same<DependentString, T>() || std::is_same<const DependentString, T>())
         return TypeCategory::DEPENDENT_STRING;
 
       if (std::is_same<OwnedString, T>() || std::is_same<const OwnedString, T>())
         return TypeCategory::OWNED_STRING;
 
       if (std::is_same<String&, T>() || std::is_same<const String&, T>() ||
         std::is_same<DependentString&, T>())
       {
@@ skipping 40 matching lines @@
           instance_function(instance_function)
     {
       name[0] = '\0';
 
       // The function parameter is a pointer to the function pointer.
       // Emscripten's "function pointers" are actually integers indicating the
       // position in the call table. 0 represents nullptr.
       if (!*reinterpret_cast<int*>(function))
         return;
 
-      char signature[256];
-      int pos = 0;
-      if (returnType == TypeCategory::DEPENDENT_STRING ||
-          returnType == TypeCategory::OWNED_STRING)
-      {
-        // Objects aren't really returned but passed as parameter. Note that
-        // this pointer might come before it but we don't care because both
-        // are integers (pointers) as far as Emscripten is concerned.
-        signature[pos++] = 'v';
-        signature[pos++] = 'i';
-      }
-      else if (returnType == TypeCategory::VOID)
-        signature[pos++] = 'v';
-      else if (returnType == TypeCategory::FLOAT)
-        signature[pos++] = 'd';
-      else if (returnType == TypeCategory::INT ||
-          returnType == TypeCategory::STRING_REF ||
-          returnType == TypeCategory::CLASS_PTR)
-      {
-        signature[pos++] = 'i';
-      }
-      else
-        throw std::runtime_error("Unexpected function return type");
-
+      std::string signature;
+
+      // Add return type to the signature. Similar logic in Emscripten:
+      // https://github.com/kripken/emscripten/blob/1.37.3/src/modules.js#L46
+      switch (returnType)
+      {
+        case TypeCategory::DEPENDENT_STRING:
+        case TypeCategory::OWNED_STRING:
+          // Technically, objects aren't really returned with clang. The caller
+          // instead adds the reference to the resulting object as an implicit
+          // parameter.
+          signature += "vi";
+          break;
+        case TypeCategory::VOID:
+          signature += 'v';
+          break;
+        case TypeCategory::FLOAT:
+          signature += 'f';
+          break;
+        case TypeCategory::DOUBLE:
+          signature += 'd';
+          break;
+        case TypeCategory::INT:
+        case TypeCategory::INT64:
+        case TypeCategory::STRING_REF:
+        case TypeCategory::CLASS_PTR:
+          signature += 'i';
+          break;
+        default:
+          throw std::runtime_error("Unexpected function return type");
+      }
+
+      // `this` pointer is an implicit parameter with clang and should be added
+      // to the signature.
       if (instance_function)
-      {
-        // this pointer is an implicit parameter
-        signature[pos++] = 'i';
-      }
-
-      for (const auto& item : argTypes)
-      {
-        if (item == TypeCategory::INT || item == TypeCategory::STRING_REF ||
-            item == TypeCategory::CLASS_PTR)
+        signature += 'i';
+
+      // Add explicit parameters to the signature, Similar logic in Emscripten:
+      // https://github.com/kripken/emscripten/blob/1.37.3/src/modules.js#L67
+      for (const auto& type : argTypes)
+      {
+        switch (type)
         {
-          signature[pos++] = 'i';
+          case TypeCategory::INT:
+          case TypeCategory::STRING_REF:
+          case TypeCategory::CLASS_PTR:
+            signature += 'i';
+            break;
+          case TypeCategory::INT64:
+            // See https://github.com/kripken/emscripten/blob/1.37.3/src/modules.js#L73,
+            // numerical types larger than 32-bit are split into multiple
+            // 32-bit parameters.
+            signature += "ii";
+            break;
+          case TypeCategory::FLOAT:
+            signature += 'f';
+            break;
+          case TypeCategory::DOUBLE:
+            signature += 'd';
+            break;
+          default:
+            throw std::runtime_error("Unexpected function argument type");
         }
-        else if (item == TypeCategory::FLOAT)
-          signature[pos++] = 'd';
-        else
-          throw std::runtime_error("Unexpected function argument type");
-        args.push_back(item);
-      }
-
-      signature[pos] = 0;
-
-      get_function_name(function, signature);
+        args.push_back(type);
+      }
+
+      get_function_name(function, signature.c_str());
     }
 
     template<typename ReturnType, typename... Args>
     FunctionInfo(ReturnType (*function)(Args...))
         : FunctionInfo(TypeInfo<ReturnType>(),
           TypeInfo<ReturnType>().pointer_type(), { TypeInfo<Args>()... }, false,
           &function)
     {
     }
 
@@ skipping 11 matching lines @@
           TypeInfo<ReturnType>().pointer_type(), { TypeInfo<Args>()... }, true,
           &function)
     {
     }
 
     bool empty() const
     {
       return name[0] == '\0';
     }
 
-    void get_function_name(void* ptr, char* signature)
+    void get_function_name(void* ptr, const char* signature)
     {
       // This is a hack, C++ won't let us get the mangled function name.
       // JavaScript is more dynamic so we pass the pointer to our function
       // there. With that and the function signature we can call the function -
       // with a full stack so that we will cause it to abort. Sometimes the
       // function we are calling will also be missing from the build. The result
       // is the same: abort() is called which in turn calls stackTrace(). By
       // replacing stackTrace() we get access to the call stack and search it
       // for the name of our function.
 
@@ skipping 170 matching lines @@
     std::string call_str(call.name);
     call_str += "(";
     for (int i = 0; i < params.size(); i++)
     {
       if (i > 0)
         call_str += ", ";
       call_str += params[i];
     }
     call_str += ")";
 
-    if (call.returnType == TypeCategory::VOID)
-      return "  " + call_str + ";\n";
-    else if (call.returnType == TypeCategory::INT ||
-          call.returnType == TypeCategory::FLOAT)
-    {
-      return "  var result = " + call_str + ";\n";
-    }
-    else if (call.returnType == TypeCategory::DEPENDENT_STRING ||
-        call.returnType == TypeCategory::OWNED_STRING)
-    {
-      std::string result;
-      result += "  var string = createString();\n";
-      result += "  " + call_str + ";\n";
-      result += "  var result = readString(string);\n";
-      if (call.returnType == TypeCategory::OWNED_STRING)
-        result += "  Module._DestroyString(string);\n";
-      return result;
-    }
-    else if (call.returnType == TypeCategory::STRING_REF)
-    {
-      return "  var result = readString(" + call_str + ");\n";
-    }
-    else if (call.returnType == TypeCategory::CLASS_PTR)
-    {
-      std::string result;
-      result += "  var result = " + call_str + ";\n";
-      result += "  if (result)\n";
-      result += "  {\n";
-
-      auto it = classes.find(call.pointerType);
-      if (it == classes.end())
-        throw std::runtime_error("Function " + std::string(call.name) + " returns pointer to unknown class");
-
-      const ClassInfo& cls = it->second;
-      auto offset = cls.subclass_differentiator.offset;
-      if (offset == SIZE_MAX)
-        result += "    result = exports." + cls.name + "(result);\n";
-      else
-        result += "    result = exports." + cls.name + ".fromPointer(result);\n";
-
-      result += "  }\n";
-      result += "  else\n";
-      result += "    result = null;\n";
-      return result;
-    }
-    else
-      throw std::runtime_error("Unexpected return type for " + std::string(call.name));
+    switch (call.returnType)
+    {
+      case TypeCategory::VOID:
+        return "  " + call_str + ";\n";
+      case TypeCategory::INT:
+      case TypeCategory::FLOAT:
+      case TypeCategory::DOUBLE:
+        return "  var result = " + call_str + ";\n";
+      case TypeCategory::INT64:
+        return "  var result = Runtime.makeBigInt(" + call_str + ", " +
+                                                  "Runtime.getTempRet0(), " +
+                                                  "true);\n";
+      case TypeCategory::DEPENDENT_STRING:
+      case TypeCategory::OWNED_STRING:
+      {
+        std::string result;
+        result += "  var string = createString();\n";
+        result += "  " + call_str + ";\n";
+        result += "  var result = readString(string);\n";
+        if (call.returnType == TypeCategory::OWNED_STRING)
+          result += "  Module._DestroyString(string);\n";
+        return result;
+      }
+      case TypeCategory::STRING_REF:
+        return "  var result = readString(" + call_str + ");\n";
+      case TypeCategory::CLASS_PTR:
+      {
+        std::string result;
+        result += "  var result = " + call_str + ";\n";
+        result += "  if (result)\n";
+        result += "  {\n";
+
+        auto it = classes.find(call.pointerType);
+        if (it == classes.end())
+          throw std::runtime_error("Function " + std::string(call.name) + " returns pointer to unknown class");
+
+        const ClassInfo& cls = it->second;
+        auto offset = cls.subclass_differentiator.offset;
+        if (offset == SIZE_MAX)
+          result += "    result = exports." + cls.name + "(result);\n";
+        else
+          result += "    result = exports." + cls.name + ".fromPointer(result);\n";
+
+        result += "  }\n";
+        result += "  else\n";
+        result += "    result = null;\n";
+        return result;
+      }
+      default:
+        throw std::runtime_error("Unexpected return type for " + std::string(call.name));
+    }
   }
 
   const std::string wrapCall(const FunctionInfo& call)
   {
-    char buffer[20];
     bool hasStringArgs = false;
     std::vector<std::string> params;
     std::string prefix = "function(";
     for (int i = 0; i < call.args.size(); i++)
     {
-      sprintf(buffer, "arg%i", i);
+      std::string argName("arg" + std::to_string(i));
       if (i > 0)
         prefix += ", ";
-      prefix += buffer;
+      prefix += argName;
 
       if (call.args[i] == TypeCategory::STRING_REF)
       {
         hasStringArgs = true;
-        params.push_back(std::string("createString(") + buffer + ")");
+        params.push_back(std::string("createString(") + argName + ")");
       }
       else if (call.args[i] == TypeCategory::CLASS_PTR)
-        params.push_back(std::string(buffer) + "._pointer");
+        params.push_back(argName + "._pointer");
+      else if (call.args[i] == TypeCategory::INT64)
+      {
+        // 64-bit integers are passed as two integer parameters
+        params.push_back(argName + " >>> 0");
+        params.push_back(argName + " / 0x100000000 >>> 0");
+      }
       else
-        params.push_back(buffer);
+        params.push_back(argName);
     }
     prefix += ")\n{\n";
 
     std::string suffix = "}";
     if (call.returnType != TypeCategory::VOID)
       suffix = "  return result;\n" + suffix;
 
     if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING || hasStringArgs)
     {
@@ skipping 268 matching lines @@
     bindings_internal::register_differentiator(
         bindings_internal::TypeInfo<ClassType>(), offset, mapping);
     return *this;
   }
 };
 
 void custom_generator(bindings_internal::CustomGenerator generator)
 {
   bindings_internal::customGenerators.push_back(generator);
 }