Issue 5137 - [emscripten] Added basic filter storage implementation

compiled/bindings/generator.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
- * Copyright (C) 2006-2017 eyeo GmbH
+ * Copyright (C) 2006-present 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <cstdio>
 
-#include <emscripten.h>
-
 #include "generator.h"
+#include "library.h"
 
 namespace
 {
   std::vector<bindings_internal::ClassInfo> classes;
-  std::vector<bindings_internal::NamespaceInfo> namespaces;
-
-  void printProperties(const bindings_internal::PropertyList& properties)
-  {
-    for (const auto& property : properties)
-    {
-      if (property.jsValue.empty())
-      {
-        printf("get %s%s,\n", property.name.c_str(),
-               wrapCall(property.getter, false).c_str());
-        if (!property.setter.empty())
-        {
-          printf("set %s%s,\n", property.name.c_str(),
-                 wrapCall(property.setter, false).c_str());
-        }
-      }
-      else
-        printf("%s: %s,\n", property.name.c_str(), property.jsValue.c_str());
-    }
-  }
-
-  void printMethods(const bindings_internal::MethodList& methods,
-                    bool instanceOnly = true)
-  {
-    for (const auto& method : methods)
-      if (!instanceOnly || method.call.instance_function)
-        printf("%s: %s,\n", method.name.c_str(), wrapCall(method.call).c_str());
-  }
 }
 
 namespace bindings_internal
 {
   FunctionInfo::FunctionInfo()
   {
-    name[0] = '\0';
   }
 
   FunctionInfo::FunctionInfo(TypeCategory returnType, TYPEID pointerType,
       std::initializer_list<TypeCategory> argTypes, bool instance_function,
       void* function)
       : returnType(returnType), pointerType(pointerType),
         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;
 
     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
@@ skipping 52 matching lines @@
           break;
         case TypeCategory::DOUBLE:
           signature += 'd';
           break;
         default:
           throw std::runtime_error("Unexpected function argument type");
       }
       args.push_back(type);
     }
 
-    get_function_name(function, signature.c_str());
+    int nameLength = GetFunctionName(nullptr, function, signature.c_str());
+    name.resize(nameLength);
+    GetFunctionName(name.data(), function, signature.c_str());
   }
 
   bool FunctionInfo::empty() const
   {
-    return name[0] == '\0';
-  }
-
-  void FunctionInfo::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.
-
-    EM_ASM_ARGS({
-      var signature = AsciiToString($2);
-      var args = [];
-      for (var i = 1; i < signature.length; i++)
-        args.push(0);
-
-      var oldPrint = Module.print;
-      var oldPrintErr = Module.printErr;
-      var oldStackTrace = stackTrace;
-      var sp = Runtime.stackSave();
-      Module.print = function(){};
-      Module.printErr = function(){};
-      stackTrace = function()
-      {
-        var stack = [];
-        for (var f = arguments.callee.caller; f; f = f.caller)
-        {
-          if (f.name)
-          {
-            if (f.name.indexOf("dynCall") == 0)
-              break;
-            else
-              stack.push(f.name);
-          }
-        }
-
-        result = stack[stack.length - 1];
-        if (result && result.indexOf("__wrapper") >= 0)
-          result = stack[stack.length - 2];
-        throw result;
-      };
-
-      Runtime.stackRestore(STACK_MAX);
-
-      try
-      {
-        Runtime.dynCall(signature, HEAP32[$1 >> 2], args);
-      }
-      catch(e)
-      {
-        Module.stringToAscii(e, $0);
-      }
-      finally
-      {
-        Runtime.stackRestore(sp);
-        Module.print = oldPrint;
-        Module.printErr = oldPrintErr;
-        stackTrace = oldStackTrace;
-      }
-    }, name, ptr, signature);
+    return name.empty();
   }
 
   ClassInfo* find_class(TYPEID classID)
   {
     for (auto& classInfo : classes)
       if (classInfo.id == classID)
         return &classInfo;
     return nullptr;
   }
 
   void register_class(const char* name, TYPEID classID, TYPEID baseClassID,
-                      ptrdiff_t ref_counted_offset)
+                      ptrdiff_t ref_counted_offset,
+                      const FunctionInfo& instanceGetter)
   {
     if (find_class(classID))
       throw std::runtime_error(std::string("Duplicate definition for class ") + name);
 
     if (baseClassID != TypeInfo<NoBaseClass>() && !find_class(baseClassID))
       throw std::runtime_error(std::string("Unknown base class defined for class ") + name);
 
     ClassInfo classInfo;
     classInfo.id = classID;
     classInfo.baseClass = baseClassID;
     classInfo.name = name;
     classInfo.subclass_differentiator.offset = SIZE_MAX;
     classInfo.ref_counted_offset = ref_counted_offset;
+    classInfo.instanceGetter = instanceGetter;
     classes.push_back(classInfo);
   }
 
   void register_property(TYPEID classID, const char* name,
       const FunctionInfo& getter, const FunctionInfo& setter,
       const char* jsValue)
   {
     ClassInfo* classInfo = find_class(classID);
     if (!classInfo)
       throw std::runtime_error(std::string("Property defined on unknown class: ") + name);
@@ skipping 26 matching lines @@
     if (!classInfo)
       throw std::runtime_error("Subclass differentiator defined on unknown class");
 
     if (classInfo->subclass_differentiator.offset != SIZE_MAX)
       throw std::runtime_error("More than one subclass differentiator defined for class " + classInfo->name);
 
     DifferentiatorInfo differentiatorInfo;
     differentiatorInfo.offset = offset;
     differentiatorInfo.mapping = mapping;
     classInfo->subclass_differentiator = differentiatorInfo;
-  }
-
-  NamespaceInfo* find_namespace(const char* namespaceName)
-  {
-    for (auto& namespaceInfo : namespaces)
-      if (namespaceInfo.name == namespaceName)
-        return &namespaceInfo;
-    return nullptr;
-  }
-
-  void register_namespace(const char* name)
-  {
-    if (find_namespace(name))
-      throw std::runtime_error(std::string("Duplicate definition for namespace ") + name);
-
-    NamespaceInfo namespaceInfo;
-    namespaceInfo.name = name;
-    namespaces.push_back(namespaceInfo);
-  }
-
-  void register_namespace_property(const char* namespaceName, const char* name,
-      const FunctionInfo& getter, const FunctionInfo& setter)
-  {
-    NamespaceInfo* namespaceInfo = find_namespace(namespaceName);
-    if (!namespaceInfo)
-      throw std::runtime_error(std::string("Property defined on unknown namespace: ") + name);
-
-    PropertyInfo propertyInfo;
-    propertyInfo.name = name;
-    propertyInfo.getter = getter;
-    propertyInfo.setter = setter;
-    namespaceInfo->properties.push_back(propertyInfo);
-  }
-
-  void register_namespace_method(const char* namespaceName, const char* name,
-      const FunctionInfo& call)
-  {
-    NamespaceInfo* namespaceInfo = find_namespace(namespaceName);
-    if (!namespaceInfo)
-      throw std::runtime_error(std::string("Method defined on unknown namespace: ") + name);
-
-    MethodInfo methodInfo;
-    methodInfo.name = name;
-    methodInfo.call = call;
-    namespaceInfo->methods.push_back(methodInfo);
   }

[Wladimir Palant, 2017/05/01 14:47:25]

I'm not really happy with the complexity required to expose namespaces. We
should probably discuss changes to the bindings definition API - maybe the code
can get considerably simpler if we go away from the embind-style APIs.

[sergei, 2017/05/08 10:54:39]

I would like to include in that discussion the design, in particular global
variables like knownFilters, FilterNotifier and subscriptions (in
FilterStorage.cpp), not loosely coupling like Listed property of subscription,
and global things mentioned above like FilterNotifier and in some other places.
So far, I find these things OK but only because it closely repeats the original
JS version, so the number of bugs should be less, but later it would be better
to reconsider such things.

In particular here, FilterStorage should be a class and we will get rid of the
namespace. However I would like to have the whole library in a namespace, if
it's a bit tricky then we could use for instance ABP prefix for everything.

[Wladimir Palant, 2017/05/08 12:55:41]

I considered making FilterStorage a singleton class. The downside here is that
calling instance methods from JavaScript is considerably less efficient while
not offering any benefit here whatsoever.

[sergei, 2017/08/24 13:32:04]

Singleton and global variables are actually equally bad from design point of
view. I would wait for finishing of the transformation, then take a look what
and how is actually used and then restructure in in way to get rid of these
global things without hurting the performance.

 
   std::string generateCall(const FunctionInfo& call,
       std::vector<std::string>& params)
   {
     if (call.returnType == TypeCategory::DEPENDENT_STRING ||
         call.returnType == TypeCategory::OWNED_STRING)
     {
       params.insert(params.begin(), "string");
     }
 
@@ skipping 13 matching lines @@
         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";
+        // We don't call a destructor here because we know that dependent
+        // strings don't need to clean up.
+        return result;
+      }
+      case TypeCategory::OWNED_STRING:
+      {
+        std::string result;
+        result += "  var string = createOwnedString();\n";
+        result += "  " + call_str + ";\n";
+        result += "  var result = readString(string);\n";
+        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";
 
         const ClassInfo* cls = find_class(call.pointerType);
         if (!cls)
-          throw std::runtime_error("Function " + std::string(call.name) + " returns pointer to unknown class");
+          throw std::runtime_error("Function " + call.name + " returns pointer to unknown class");
 
         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));
-    }
-  }
-
-  std::string wrapCall(const FunctionInfo& call, bool isFunction)
+        throw std::runtime_error("Unexpected return type for " + call.name);
+    }
+  }
+
+  std::string wrapCall(const FunctionInfo& call, bool isFunction,
+      const FunctionInfo& instanceGetter)
   {
     bool hasStringArgs = false;
     std::vector<std::string> params;
     std::string prefix;
 
     if (isFunction)
       prefix += "function";
     prefix += "(";
     for (int i = 0; i < call.args.size(); i++)
     {
       std::string argName("arg" + std::to_string(i));
       if (i > 0)
         prefix += ", ";
       prefix += argName;
 
       if (call.args[i] == TypeCategory::STRING_REF)
       {
         hasStringArgs = true;
         params.push_back(std::string("createString(") + argName + ")");
       }
       else if (call.args[i] == TypeCategory::CLASS_PTR)
         params.push_back(argName + " ? " + argName + "._pointer : 0");

[Wladimir Palant, 2017/05/01 14:47:25]

Turns out we weren't supporting null for parameters expecting a class.

[sergei, 2017/05/08 10:54:39]

In addition I wonder whether we can use C++ references, we do use them for
strings already, why not to use them also for other objects.

[Wladimir Palant, 2017/05/08 12:55:41]

We could use references easily but these won't be references in JavaScript. The
bindings code will then have to make sure that no null pointers are passed in.
So far this didn't seem to be worth doing but we can certainly consider it.

[sergei, 2017/08/24 13:32:04]

Currently one has to manually test whether a pointer argument is null or not
each time in a method implementation, however many functions expect a real
object and this testing is just additional code which can be avoided. Therefore
using C++ references is safer and easier in many cases. However, if we
accidentally pass not a "real object" from JS into a function which does not
expect it, it would be better to generate the check into bindings than manually
implement it in a method implementation.

In addition I guess we should think about it a little bit more because it can
help to develop some other conventions, e.g. ref_counted objects should be
always allocated on heap and never on the stack.

[Wladimir Palant, 2017/08/31 11:32:34]

I filed https://issues.adblockplus.org/ticket/5603 on that.

       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(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)
     {
       prefix += "  var sp = Runtime.stackSave();\n";
       suffix = "  Runtime.stackRestore(sp);\n" + suffix;
     }
 
     if (call.instance_function)
-      params.insert(params.begin(), "this._pointer");
+    {
+      if (instanceGetter.empty())
+        params.insert(params.begin(), "this._pointer");
+      else
+        params.insert(params.begin(), instanceGetter.name + "()");
+    }
 
     return prefix + generateCall(call, params) + suffix;
   }
 
   void printHelpers()
   {
     printf("var sizeofString = %i;\n", sizeof(String));
 
     puts(R"(
       function copyString(str, buffer)
       {
         var length = str.length;
         for (var i = 0, pointer = (buffer >> 1); i < length; i++, pointer++)
           HEAP16[pointer] = str.charCodeAt(i);
         return length;
       }
 
       function createString(str)
       {
         var length = 0;
         var buffer = 0;
         if (str)
         {
           buffer = Runtime.stackAlloc(str.length * 2);
           length = copyString(str, buffer);
         }
 
         var result = Runtime.stackAlloc(sizeofString);
         Module._InitString(result, buffer, length);
+        return result;
+      }
+
+      function createOwnedString()
+      {
+        var result = Runtime.stackAlloc(sizeofString);
+        Module._InitOwnedString(result);
         return result;
       }
 
       function readString(str)
       {
         var length = Module._GetStringLength(str);
         var pointer = Module._GetStringData(str) >> 1;
         return String.fromCharCode.apply(String, HEAP16.slice(pointer, pointer + length));
       }
 
@@ skipping 10 matching lines @@
           Module._ReleaseRef(this._pointer + ref_counted_offset);
         };
         return result;
       }
     )");
   }
 
   void printClass(const ClassInfo& cls)
   {
     // Begin class definition
-    ClassInfo* baseClass = find_class(cls.baseClass);
-    printf("exports.%s = createClass(%s, %i, {\n", cls.name.c_str(),
-        (baseClass ? ("exports." + baseClass->name).c_str() : "null"),
-        cls.ref_counted_offset);
+    bool singleton = !cls.instanceGetter.empty();
+    if (singleton)
+      printf("exports.%s = {\n", cls.name.c_str());
+    else
+    {
+      ClassInfo* baseClass = find_class(cls.baseClass);
+      printf("exports.%s = createClass(%s, %i, {\n", cls.name.c_str(),
+          (baseClass ? ("exports." + baseClass->name).c_str() : "null"),
+          cls.ref_counted_offset);
+    }
 
     // Print prototype members
-    printProperties(cls.properties);
-    printMethods(cls.methods);
+    for (const auto& property : cls.properties)
+    {
+      if (property.jsValue.empty())
+      {
+        printf("get %s%s,\n", property.name.c_str(),
+               wrapCall(property.getter, false, cls.instanceGetter).c_str());
+        if (!property.setter.empty())
+        {
+          printf("set %s%s,\n", property.name.c_str(),
+                 wrapCall(property.setter, false, cls.instanceGetter).c_str());
+        }
+      }
+      else
+        printf("%s: %s,\n", property.name.c_str(), property.jsValue.c_str());
+    }
+
+    for (const auto& method : cls.methods)
+    {
+      if (method.call.instance_function)
+      {
+        printf("%s: %s,\n",
+            method.name.c_str(),
+            wrapCall(method.call, true, cls.instanceGetter).c_str());
+      }
+    }
 
     // End class definition
-    printf("});\n");
+    if (singleton)
+      printf("};\n");
+    else
+      printf("});\n");
 
     // Print static members
     DifferentiatorInfo differentiator = cls.subclass_differentiator;
     if (differentiator.offset != SIZE_MAX)
     {
-      printf("var %s_mapping = \n", cls.name.c_str());
-      puts("{");
-      for (const auto& item : differentiator.mapping)
-        printf("  %i: '%s',\n", item.first, item.second.c_str());
-      puts("};");
-
       printf("exports.%s.fromPointer = function(ptr)\n", cls.name.c_str());
       puts("{");
       printf("  var type = HEAP32[ptr + %i >> 2];\n", differentiator.offset);
       printf("  if (type in %s_mapping)\n", cls.name.c_str());
-      printf("    return new (exports[%s_mapping[type]])(ptr);\n", cls.name.c_str());
+      printf("    return new %s_mapping[type](ptr);\n", cls.name.c_str());
       printf("  throw new Error('Unexpected %s type: ' + type);\n", cls.name.c_str());
       puts("};");
     }
     else
     {
       printf("exports.%s.fromPointer = function(ptr)\n", cls.name.c_str());
       puts("{");
       printf("  return new exports.%s(ptr);\n", cls.name.c_str());
       puts("};");
     }
 
     for (const auto& method : cls.methods)
     {
       if (!method.call.instance_function)
       {
         printf("exports.%s.%s = %s;\n", cls.name.c_str(), method.name.c_str(),
                wrapCall(method.call).c_str());
       }
     }
   }
 
-  void printNamespace(const NamespaceInfo& namespaceInfo)
-  {
-    printf("exports.%s = {\n", namespaceInfo.name.c_str());
-    printProperties(namespaceInfo.properties);
-    printMethods(namespaceInfo.methods, false);
-    puts("};");
+  void printClassMapping(const ClassInfo& cls)
+  {
+      DifferentiatorInfo differentiator = cls.subclass_differentiator;
+      if (differentiator.offset == SIZE_MAX)
+        return;
+
+      printf("var %s_mapping = \n", cls.name.c_str());
+      puts("{");
+      for (const auto& item : differentiator.mapping)
+        printf("  %i: exports.%s,\n", item.first, item.second.c_str());
+      puts("};");
   }
 }
 
 void printBindings()
 {
   bindings_internal::printHelpers();
 
-  for (const auto& item : classes)
-    bindings_internal::printClass(item);
-  for (const auto& item : namespaces)
-    bindings_internal::printNamespace(item);
+  for (const auto& cls : classes)
+    bindings_internal::printClass(cls);
+  for (const auto& cls : classes)
+    bindings_internal::printClassMapping(cls);
 }