Experiment to factor out GC into its own project

build.sbt

@@ -14,6 +14,7 @@ lazy val toolsBenchmarks          = Build.toolsBenchmarks
 lazy val toolsJVM                 = Build.toolsJVM
 lazy val nativelib                = Build.nativelib
 lazy val clib                     = Build.clib
+lazy val gclib                    = Build.gclib
 lazy val posixlib                 = Build.posixlib
 lazy val windowslib               = Build.windowslib
 lazy val javalib                  = Build.javalib

docs/user/native.rst

@@ -84,4 +84,79 @@ transparent to the library user.
 Using a library that contains native code can be used in combination with
 the feature above that allows native code in your application.
 
+EXPERIMENTAL: Deployment Descriptor for Conditional Compilation
+---------------------------------------------------------------
+
+This is an **experimental** feature. Scala Native may deprecate or
+remove this feature with little or no warning.
+
+Libraries developed with "glue" code as described in the above section
+can cause compilation errors when all the following conditions occur:
+
+1. The library and/or header files are not installed
+
+2. The dependency is in the library users' build
+
+3. The code that uses the "glue" code is not called by the application
+   or library
+
+If the glue "code" is being called, then the library and headers need to
+be installed to compile your application otherwise errors are expected.
+
+Scala Native code can include the annotation ``@link("z")`` for example
+that says link with the ``z`` library. The compiler will add a link
+option for this library to the linking phase of the build if the code
+with the annotation is used. See :ref:`interop`,
+`Linking with native libraries` section for more information.
+
+This **experimental** feature has been added so the users of your published
+library can avoid the error described above. Use the following procedure to
+implement this feature.
+
+1. Add a Scala Native deployment descriptor to your library. For the
+purposes of this example assume the library is ``z``. The properties file
+must be named ``scala-native.properties`` and must be put in the base of the
+``src/main/resources/scala-native`` directory.
+
+2. Add the following content to your new ``scala-native.properties`` file.
+Note that if your library has more that one library you can add a comma
+delimited list of libraries. If desired, the comments are not needed.
+
+.. code-block:: properties
+
+    # configuration for glue code
+    # defines SCALANATIVE_LINK_Z if @link("z") annnotation is used (found in NIR)
+    # libraries used, comma delimited
+    nir.link.names = z
+
+3. Now in your native "glue" code add the following. The macro is named
+``SCALANATIVE_LINK_`` plus the uppercased name of the library.
+
+.. code-block:: c
+
+    #ifdef SCALANATIVE_LINK_Z
+
+    #include <zlib.h>
+
+    int scalanative_z_no_flush() { return Z_NO_FLUSH; }
+    // other functions
+
+    #endif
+
+The feature works by querying the NIR code to see if the user code is using the
+``z`` library. If used, ``-DSCALANATIVE_LINK_Z`` is passed to the compiler
+and your "glue" code is then compiled. Otherwise, the macro keeps the code
+inside from compiling. The project dependencies with native code are compiled
+individually so this feature only applies to the current library being compiled.
+
+Conceivably, another dependency could fail if this feature is not used which
+could fail the whole build. The users of the native libraries should install the
+required libraries they are using. This feature can make the dependency optional
+if not used.
+
+There are other valid use cases where this feature is needed. For example,
+when Scala Native libraries use more that one native library but all the native
+libraries do not have to be used. This allows the users to only install the
+libraries they actually need for their particular application.
+
 Continue to :ref:`testing`.

gclib/src/main/resources/scala-native/platform/unwind.h

@@ -0,0 +1,16 @@
+#ifndef UNWIND_H
+#define UNWIND_H
+
+#include <stddef.h>
+
+int scalanative_unwind_get_context(void *context);
+int scalanative_unwind_init_local(void *cursor, void *context);
+int scalanative_unwind_step(void *cursor);
+int scalanative_unwind_get_proc_name(void *cursor, char *buffer, size_t length,
+                                     void *offset);
+int scalanative_unwind_get_reg(void *cursor, int regnum, size_t *valp);
+int scalanative_unw_reg_ip();
+size_t scalanative_unwind_sizeof_context();
+size_t scalanative_unwind_sizeof_cursor();
+
+#endif

gclib/src/main/resources/scala-native/scala-native.properties

@@ -0,0 +1,4 @@
+# from the pom specification
+project.groupId = org.scala-native
+project.artifactId = gclib
+

gclib/src/main/scala-next/scala/scalanative/memory/SafeZone.scala

@@ -0,0 +1,67 @@
+package scala.scalanative.memory
+
+import language.experimental.captureChecking
+import scalanative.unsigned._
+import scala.annotation.implicitNotFound
+import scala.scalanative.unsafe.CSize
+import scala.scalanative.unsigned.USize
+import scala.scalanative.runtime.{RawPtr, RawSize, SafeZoneAllocator, Intrinsics}
+import scala.scalanative.runtime.SafeZoneAllocator.allocate
+
+@implicitNotFound("Given method requires an implicit zone.")
+trait SafeZone {
+
+  /** Return this zone is open or not. */
+  def isOpen: Boolean
+
+  /** Return this zone is closed or not. */
+  def isClosed: Boolean = !isOpen
+
+  /** Require this zone to be open. */
+  def checkOpen(): Unit = {
+    if (!isOpen)
+      throw new IllegalStateException(s"Zone ${this} is already closed.")
+  }
+
+  /** Allocates an object in this zone. The expression of obj must be an instance creation expression. */
+  infix inline def alloc[T <: AnyRef](inline obj: T): T^{this} = allocate(this, obj)
+
+  /** Frees allocations. This zone is not reusable once closed. */
+  private[scalanative] def close(): Unit
+
+  /** Return the handle of this zone. */
+  private[scalanative] def handle: RawPtr
+
+  /** The low-level implementation of allocation. This function shouldn't be inlined because it's directly called in the lowering phase. */
+  @noinline
+  private[scalanative] def allocImpl(cls: RawPtr, size: RawSize): RawPtr = {
+    checkOpen()
+    SafeZoneAllocator.Impl.alloc(handle, cls, USize(size).asInstanceOf[CSize])
+  }
+}
+
+object SafeZone {
+  /** Run given function with a fresh zone and destroy it afterwards. */
+  final def apply[sealed T](f: (SafeZone^) ?=> T): T = {
+    val sz: SafeZone^ = new MemorySafeZone(SafeZoneAllocator.Impl.open())
+    try f(using sz)
+    finally sz.close()
+  }
+
+  /* Allocates an object in the implicit zone. The expression of obj must be an instance creation expression. */
+  inline def alloc[T <: AnyRef](inline obj: T)(using inline sz: SafeZone^): T^{sz} = allocate(sz, obj)
+
+  /** Summon the implicit zone. */
+  transparent inline def zone(using sz: SafeZone^): SafeZone^{sz} = sz
+
+  private class MemorySafeZone (private[scalanative] val handle: RawPtr) extends SafeZone {
+    private[this] var flagIsOpen = true
+    override def isOpen: Boolean = flagIsOpen
+    override def close(): Unit = {
+      checkOpen()
+      flagIsOpen = false
+      SafeZoneAllocator.Impl.close(handle)
+    }
+  }
+
+}

gclib/src/main/scala-next/scala/scalanative/runtime/SafeZoneAllocator.scala

@@ -0,0 +1,26 @@
+package scala.scalanative.runtime 
+
+import language.experimental.captureChecking
+import scala.scalanative.memory.SafeZone
+import scala.scalanative.unsafe._
+
+/**
+  * We can move SafeZoneAllocator to package `memory` and make it 
+  * `private[scalanative]` after dotty supports using `new {sz} T(...)` 
+  * to create new instance allocated in sz. Currently, we need it not 
+  * private to package scalanative for unit tests.
+*/
+object SafeZoneAllocator {
+  def allocate[T](sz: SafeZone^, obj: T): T^{sz} = intrinsic
+
+  @extern object Impl{
+    @name("scalanative_zone_open")
+    def open(): RawPtr = extern
+
+    @name("scalanative_zone_alloc")
+    def alloc(rawzone: RawPtr, rawty: RawPtr, size: CSize): RawPtr = extern
+
+    @name("scalanative_zone_close")
+    def close(rawzone: RawPtr): Unit = extern
+  }
+}

gclib/src/main/scala/scala/scalanative/memory/SafeZone.scala

@@ -0,0 +1,16 @@
+package scala.scalanative.memory
+
+import scala.scalanative.runtime.{RawPtr, RawSize, intrinsic}
+
+/** Placeholder for SafeZone. It's used to avoid linking error when using scala
+ *  versions other than scala-next, since the type `SafeZone` is used in the
+ *  lowering phase.
+ */
+private[scalanative] trait SafeZone {
+
+  /** Placeholder for `allocImpl` method, which is used in the alloc: Int ->
+   *  SafeZone -> Unit method in Arrays. Similarly, it's needed because the
+   *  alloc method is used in the lowering phase.
+   */
+  def allocImpl(cls: RawPtr, size: RawSize): RawPtr = intrinsic
+}

gclib/src/main/scala/scala/scalanative/unsafe/Zone.scala

@@ -0,0 +1,36 @@
+package scala.scalanative
+package unsafe
+
+import scala.annotation.implicitNotFound
+import scalanative.runtime.{MemoryPool, MemoryPoolZone}
+
+/** Zone allocator which manages memory allocations. */
+@implicitNotFound("Given method requires an implicit zone.")
+trait Zone {
+
+  /** Allocates memory of given size. */
+  def alloc(size: CSize): Ptr[Byte]
+
+  /** Frees allocations. This zone allocator is not reusable once closed. */
+  def close(): Unit
+
+  /** Return this zone allocator is open or not. */
+  def isOpen: Boolean = !isClosed
+
+  /** Return this zone allocator is closed or not. */
+  def isClosed: Boolean
+
+}
+
+object Zone {
+
+  /** Run given function with a fresh zone and destroy it afterwards. */
+  final def apply[T](f: Zone => T): T = {
+    val zone = open()
+    try f(zone)
+    finally zone.close()
+  }
+
+  /** Create a new zone allocator. Use Zone#close to free allocations. */
+  final def open(): Zone = MemoryPoolZone.open(MemoryPool.defaultMemoryPool)
+}

javalib/src/main/resources/scala-native/scala-native.properties

@@ -0,0 +1,8 @@
+# from the pom specification
+project.groupId = org.scala-native
+project.artifactId = javalib
+
+# configuration for glue code
+# defines SCALANATIVE_LINK_Z if @link("z") annnotation is used (found in NIR)
+# libraries used, comma delimited
+nir.link.names = z

nativelib/src/main/resources/scala-native/optional/z.c → javalib/src/main/resources/scala-native/z.c

@@ -1,3 +1,5 @@
+#ifdef SCALANATIVE_LINK_Z
+
 #include <zlib.h>
 
 int scalanative_z_no_flush() { return Z_NO_FLUSH; }
@@ -252,3 +254,4 @@ uLong scalanative_crc32(uLong crc, Bytef *buf, uInt len) {
 uLong scalanative_crc32_combine(uLong crc1, uLong crc2, z_off_t len2) {
     return crc32_combine(crc1, crc2, len2);
 }
+#endif

nativelib/src/main/resources/scala-native/scala-native.properties

@@ -0,0 +1,6 @@
+# from the pom specification
+# need to identify this project because the build has special logic
+# to compile the selected Garbage Collector
+project.groupId = org.scala-native
+project.artifactId = nativelib
+

project/BinaryIncompatibilities.scala

@@ -45,6 +45,7 @@ object BinaryIncompatibilities {
 
   final val NativeLib = Seq.empty
   final val CLib: Filters = Nil
+  final val GcLib: Filters = Nil
   final val PosixLib: Filters = Seq.empty
   final val WindowsLib: Filters = Nil
 
@@ -60,6 +61,7 @@ object BinaryIncompatibilities {
     "nscplugin" -> NscPlugin,
     "tools" -> Tools,
     "clib" -> CLib,
+    "gclib" -> GcLib,
     "posixlib" -> PosixLib,
     "windowslib" -> WindowsLib,
     "nativelib" -> NativeLib,

project/Build.scala

@@ -29,8 +29,7 @@ object Build {
   lazy val compilerPlugins =  List(nscPlugin, junitPlugin)
   lazy val publishedMultiScalaProjects = compilerPlugins ++ List(
     nir, util, tools,
-    nirJVM, utilJVM, toolsJVM,
-    nativelib, clib, posixlib, windowslib,
+    nativelib, clib, gclib, posixlib, windowslib,
     auxlib, javalib, scalalib,
     testInterface, testInterfaceSbtDefs, testRunner,
     junitRuntime
@@ -450,6 +449,7 @@ object Build {
                     // Native libraries
                     nativelib.forBinaryVersion(ver) / publishLocal,
                     clib.forBinaryVersion(ver) / publishLocal,
+                    gclib.forBinaryVersion(ver) / publishLocal,
                     posixlib.forBinaryVersion(ver) / publishLocal,
                     windowslib.forBinaryVersion(ver) / publishLocal,
                     // Standard language libraries
@@ -481,34 +481,38 @@ object Build {
       .dependsOn(toolsJVM.v2_12, testRunner.v2_12)
 
 // Native moduels ------------------------------------------------
-  lazy val nativelib =
-    MultiScalaProject("nativelib")
-      .enablePlugins(MyScalaNativePlugin)
-      .settings(
-        mavenPublishSettings,
-        docsSettings,
-        libraryDependencies ++= Deps.NativeLib(scalaVersion.value)
-      )
-      .withNativeCompilerPlugin
+  lazy val nativelib: MultiScalaProject = MultiScalaProject("nativelib")
+    .enablePlugins(MyScalaNativePlugin)
+    .settings(
+      mavenPublishSettings,
+      docsSettings,
+      libraryDependencies ++= Deps.NativeLib(scalaVersion.value)
+    )
+    .withNativeCompilerPlugin
 
   lazy val clib = MultiScalaProject("clib")
     .enablePlugins(MyScalaNativePlugin)
     .settings(mavenPublishSettings)
     .dependsOn(nativelib)
     .withNativeCompilerPlugin
 
+  lazy val gclib = MultiScalaProject("gclib")
+    .enablePlugins(MyScalaNativePlugin)
+    .settings(mavenPublishSettings)
+    .dependsOn(nativelib)
+    .withNativeCompilerPlugin
+
   lazy val posixlib = MultiScalaProject("posixlib")
     .enablePlugins(MyScalaNativePlugin)
     .settings(mavenPublishSettings)
     .dependsOn(nativelib, clib)
     .withNativeCompilerPlugin
 
-  lazy val windowslib =
-    MultiScalaProject("windowslib")
-      .enablePlugins(MyScalaNativePlugin)
-      .settings(mavenPublishSettings)
-      .dependsOn(nativelib, clib)
-      .withNativeCompilerPlugin
+  lazy val windowslib = MultiScalaProject("windowslib")
+    .enablePlugins(MyScalaNativePlugin)
+    .settings(mavenPublishSettings)
+    .dependsOn(nativelib, clib)
+    .withNativeCompilerPlugin
 
 // Language standard libraries ------------------------------------------------
   lazy val javalib = MultiScalaProject("javalib")
@@ -590,7 +594,7 @@ object Build {
             }
           )
       }
-      .dependsOn(auxlib, javalib)
+      .dependsOn(auxlib, javalib, gclib)
 
   // Tests ------------------------------------------------
   lazy val tests = MultiScalaProject("tests", file("unit-tests") / "native")

sbt-scala-native/src/main/scala/scala/scalanative/sbtplugin/ScalaNativePluginInternal.scala

@@ -45,7 +45,15 @@ object ScalaNativePluginInternal {
     taskKey[Unit]("Warn if JVM 7 or older is used.")
 
   private val nativeStandardLibraries =
-    Seq("nativelib", "clib", "posixlib", "windowslib", "javalib", "auxlib")
+    Seq(
+      "nativelib",
+      "clib",
+      "gclib",
+      "posixlib",
+      "windowslib",
+      "javalib",
+      "auxlib"
+    )
 
   lazy val scalaNativeDependencySettings: Seq[Setting[_]] = Seq(
     libraryDependencies ++= Seq(