Skip functions that pass arrays or structs by value

Author: kornilova203

bindgen/ir/Function.cpp

@@ -1,5 +1,6 @@
 #include "Function.h"
 #include "../Utils.h"
+#include "Struct.h"
 
 Parameter::Parameter(std::string name, std::shared_ptr<Type> type)
     : TypeAndName(std::move(name), type) {}
@@ -71,3 +72,23 @@ Function::~Function() {
         delete parameter;
     }
 }
+
+bool Function::isLegalScalaNativeFunction() const {
+    /* structs and unions are used only through corresponding TypeDefs so it's
+     * okay to cast only to TypeDef.
+     * Return type and parameters types cannot be array types because array type
+     * in this case is always represented as a pointer to element type */
+    auto *typeDef = dynamic_cast<TypeDef *>(retType.get());
+    if (typeDef &&
+        (typeDef->isAliasFor<Struct>() || typeDef->isAliasFor<ArrayType>())) {
+        return false;
+    }
+    for (const auto &parameter : parameters) {
+        typeDef = dynamic_cast<TypeDef *>(parameter->getType().get());
+        if (typeDef && (typeDef->isAliasFor<Struct>() ||
+                        typeDef->isAliasFor<ArrayType>())) {
+            return false;
+        }
+    }
+    return true;
+}

bindgen/ir/Function.h

@@ -2,6 +2,7 @@
 #define SCALA_NATIVE_BINDGEN_FUNCTION_H
 
 #include "TypeAndName.h"
+#include "TypeDef.h"
 #include <llvm/Support/raw_ostream.h>
 #include <string>
 #include <vector>
@@ -27,6 +28,12 @@ class Function {
 
     void setScalaName(std::string scalaName);
 
+    /**
+     * @return true if the function does not use values of structs or arrays
+     * (note: unions are represented as arrays)
+     */
+    bool isLegalScalaNativeFunction() const;
+
   private:
     std::string getVarargsParameterName() const;
 

bindgen/ir/IR.cpp

@@ -122,7 +122,15 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         }
 
         for (const auto &func : ir.functions) {
-            s << *func;
+            if (func->isLegalScalaNativeFunction()) {
+                s << *func;
+            } else {
+                llvm::errs()
+                    << "Warning: Function " << func->getName()
+                    << " is skipped because Scala Native does not support "
+                       "passing structs and arrays by value.\n";
+                llvm::errs().flush();
+            }
         }
 
         s << "}\n\n";

bindgen/ir/TypeDef.h

@@ -23,6 +23,27 @@ class TypeDef : public TypeAndName, public Type {
 
     std::shared_ptr<Location> getLocation() const;
 
+    /**
+     * @tparam T Type
+     * @return true if the typedef is an alias for give type directly or through
+     * a chain of typedefs
+     */
+    template <typename T> bool isAliasFor() const {
+        /* if body is moved to cpp file then linker gives undefined symbols
+         * error */
+        if (!type) {
+            return false;
+        }
+        if (dynamic_cast<T *>(type.get())) {
+            return true;
+        }
+        auto *typeDef = dynamic_cast<TypeDef *>(type.get());
+        if (typeDef) {
+            return typeDef->isAliasFor<T>();
+        }
+        return false;
+    }
+
   private:
     /**
      * nullptr if type is generated.

tests/samples/Function.h

@@ -4,3 +4,21 @@ char one_arg(int a);
 void *two_args(float a, int b);
 double anonymous_args(float, int);
 double variadic_args(double a, char *varArgs, ...);
+
+struct s {
+    int val;
+};
+
+void acceptsStructValue(struct s); // function is skipped with warning
+
+typedef struct s s;
+
+s returnsStructValue(); // function is skipped with warning
+
+union u {
+    int a;
+};
+
+void acceptsUnionValue(union u); // function is skipped with warning
+
+void acceptsArray(int[10]); // it's okay because the type is pointer to int

tests/samples/Function.scala

@@ -6,10 +6,32 @@ import scala.scalanative.native._
 @native.link("bindgentests")
 @native.extern
 object Function {
+  type struct_s = native.CStruct1[native.CInt]
+  type s = struct_s
+  type union_u = native.CArray[Byte, native.Nat._4]
   def no_args(): native.CInt = native.extern
   def void_arg(): native.CFloat = native.extern
   def one_arg(a: native.CInt): native.CChar = native.extern
   def two_args(a: native.CFloat, b: native.CInt): native.Ptr[Byte] = native.extern
   def anonymous_args(anonymous0: native.CFloat, anonymous1: native.CInt): native.CDouble = native.extern
   def variadic_args(a: native.CDouble, varArgs: native.CString, varArgs0: native.CVararg*): native.CDouble = native.extern
+  def acceptsArray(anonymous0: native.Ptr[native.CInt]): Unit = native.extern
 }
+
+import Function._
+
+object FunctionHelpers {
+
+  implicit class struct_s_ops(val p: native.Ptr[struct_s]) extends AnyVal {
+    def `val`: native.CInt = !p._1
+    def `val_=`(value: native.CInt): Unit = !p._1 = value
+  }
+
+  def struct_s()(implicit z: native.Zone): native.Ptr[struct_s] = native.alloc[struct_s]
+
+  implicit class union_u_pos(val p: native.Ptr[union_u]) extends AnyVal {
+    def a: native.Ptr[native.CInt] = p.cast[native.Ptr[native.CInt]]
+    def a_=(value: native.CInt): Unit = !p.cast[native.Ptr[native.CInt]] = value
+  }
+}
+

tests/samples/PrivateMembers.h

@@ -38,7 +38,7 @@ void __privateFunction();
 
 // functions that should not be removed:
 __private_type *getPrivateType();
-void usesPrivateUnion(union __unionWithPrivateName);
+void usesPrivateUnion(union __unionWithPrivateName *);
 void usesPrivateStruct(struct structWithPrivateType *, struct normalStruct *);
 void usesPrivateEnum(enum __privateEnum *);
 

tests/samples/PrivateMembers.scala

@@ -19,7 +19,7 @@ object PrivateMembers {
   type privateStructWithTypedefPtr = native.Ptr[struct_privateStructWithTypedef]
   def getTypeThatUsesPrivateTypes(): pid_t = native.extern
   def getPrivateType(): native.Ptr[__private_type] = native.extern
-  def usesPrivateUnion(anonymous0: union___unionWithPrivateName): Unit = native.extern
+  def usesPrivateUnion(anonymous0: native.Ptr[union___unionWithPrivateName]): Unit = native.extern
   def usesPrivateStruct(anonymous0: native.Ptr[struct_structWithPrivateType], anonymous1: native.Ptr[struct_normalStruct]): Unit = native.extern
   def usesPrivateEnum(anonymous0: native.Ptr[enum___privateEnum]): Unit = native.extern
 }

tests/samples/ReservedWords.h

@@ -20,7 +20,7 @@ union lazy {
 
 typedef union lazy lazy;
 
-type with(match sealed, var implicit, lazy forSome);
+type *with(match sealed, var implicit, lazy *forSome);
 
 typedef match def;
 typedef struct {

tests/samples/ReservedWords.scala

@@ -16,7 +16,7 @@ object ReservedWords {
   type `def` = `match`
   type struct_finally = native.CStruct2[`def`, `lazy`]
   type `finally` = struct_finally
-  def `with`(`sealed`: `match`, `implicit`: native.Ptr[`match`], `forSome`: `lazy`): `type` = native.extern
+  def `with`(`sealed`: `match`, `implicit`: native.Ptr[`match`], `forSome`: native.Ptr[`lazy`]): native.Ptr[`type`] = native.extern
   def `implicit`(`type`: native.Ptr[`finally`]): `match` = native.extern
   def _1(): Unit = native.extern
 }