Add example project which generates a dynamic library using gccjit

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.gradle
+build
+*.so

CHANGELOG.md

@@ -1,4 +1,5 @@
 
+- Add example project which generates a dynamic library using gccjit
 - Adjust generated sources path to match other JavaCPP presets
 - Add experimental build for Linux ppc64le ([pull #5](https://github.com/bytedeco/gcc/pull/5))
 - Add environment for running aarch64, ppc64le, armhf builds ([pull #6](https://github.com/bytedeco/gcc/pull/6))

README.md

@@ -31,5 +31,138 @@ from the rest of the JavaCPP Presets CI envs. This is a temporary solution and
 primarily a proof-of-concept. Please open an issue/discussion if you're in need 
 of these architectures or if an architecture you need is not available.
 
+## Sample Usage
+
+This is an example showing how to build and generate code via libgccjit and 
+outputting it into a dynamic library.
+[/samples/code-generation/](samples/code-generation)
+
+> Sample showing how to call JIT-generated functions is work-in-progress.
+
+We can use Gradle to install the required dependencies and native binaries 
+built by JavaCPP.
+
+The `build.gradle` build file
+
+```groovy
+plugins {
+    id("application")
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
+}
+
+dependencies {
+    implementation("org.bytedeco:gcc-platform:10.2.0-1.5.5-SNAPSHOT")
+}
+
+application {
+    mainClass = 'HelloWorld'
+}
+```
+
+The `DylibGenerator.java` source file
+
+```java
+import org.bytedeco.gcc.gccjit.*;
+import org.bytedeco.javacpp.*;
+
+import static org.bytedeco.gcc.global.gccjit.*;
+
+public class DylibGenerator {
+    public static void main(String[] args) {
+        gcc_jit_context ctxt = gcc_jit_context_acquire();
+        gcc_jit_context_set_bool_option(ctxt, GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, 1);
+
+        create_code(ctxt);
+
+        gcc_jit_context_compile_to_file(ctxt, GCC_JIT_OUTPUT_KIND_DYNAMIC_LIBRARY, "libhello.so");
+        gcc_jit_context_release(ctxt);
+    }
+
+    public static void create_code(gcc_jit_context ctxt) {
+        gcc_jit_type void_type = gcc_jit_context_get_type(ctxt, GCC_JIT_TYPE_VOID);
+        gcc_jit_type const_char_ptr_type = gcc_jit_context_get_type(ctxt, GCC_JIT_TYPE_CONST_CHAR_PTR);
+        gcc_jit_type int_type = gcc_jit_context_get_type(ctxt, GCC_JIT_TYPE_INT);
+        gcc_jit_param param_name = gcc_jit_context_new_param(ctxt, null, const_char_ptr_type, "name");
+        gcc_jit_param[] func_params = { param_name };
+
+        PointerPointer<gcc_jit_param> func_params_ptr = new PointerPointer<>(func_params);
+        BytePointer func_name = new BytePointer("greet");
+        gcc_jit_function greet_func = gcc_jit_context_new_function(ctxt, null, GCC_JIT_FUNCTION_EXPORTED, void_type,
+            func_name, func_params.length, func_params_ptr, 0);
+
+        gcc_jit_param param_format = gcc_jit_context_new_param(ctxt, null, const_char_ptr_type, "format");
+        gcc_jit_param[] printf_params = { param_format };
+
+        PointerPointer<gcc_jit_param> printf_params_ptr = new PointerPointer<>(printf_params);
+        BytePointer printf_name = new BytePointer("printf");
+        gcc_jit_function printf_func = gcc_jit_context_new_function(ctxt, null, GCC_JIT_FUNCTION_IMPORTED, int_type,
+            printf_name, printf_params.length, printf_params_ptr, 0);
+
+        gcc_jit_block block = gcc_jit_function_new_block(greet_func, "entry");
+        BytePointer format = new BytePointer("hello %s\\n");
+        gcc_jit_rvalue format_rvalue = gcc_jit_context_new_rvalue_from_ptr(ctxt, const_char_ptr_type, format);
+        gcc_jit_rvalue call = gcc_jit_context_new_call(ctxt, null, printf_func, 1, format_rvalue);
+        gcc_jit_block_add_eval(block, null, call);
+
+        gcc_jit_block_end_with_void_return(block, null);
+
+        func_name.deallocate();
+        func_params_ptr.deallocate();
+        printf_name.deallocate();
+        printf_params_ptr.deallocate();
+        format.deallocate();
+    }
+}
+```
+
+> The below explanation assumes a Linux environment. I tested this on Linux 
+> x86_64
+
+The above program should output something similar to the following to the 
+terminal window on x86_64. Assembler output for other architectures will 
+obviously be different.
+
+```asm
+	.file	"fake.c"
+	.text
+	.globl	greet
+	.type	greet, @function
+greet:
+.LFB0:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movq	%rdi, -8(%rbp)
+.L2:
+	movabsq	$139992918400400, %rdi
+	call	printf@PLT
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	greet, .-greet
+	.ident	"GCC: (GNU) 10.2.0"
+	.section	.note.GNU-stack,"",@progbits
+```
+
+The `$139992918400400` operand to the movabsq instruction is expected as 
+it refers to our `"hello %s\n"` string we created.
+
+If we look in the directory we invoked the program in we should have a 
+`libhello.so` file which is dynamically linkable. Looking inside the shared 
+library file with `nm libhello.so | grep "greet"` we can see that the greet 
+function is indeed there.
+
 [javacpp-presets]: https://github.com/bytedeco/javacpp-presets#readme
-[libgccjit]: https://gcc.gnu.org/wiki/JIT
+[libgccjit]: https://gcc.gnu.org/wiki/JIT
+

build.gradle

@@ -11,14 +11,15 @@ group = "org.bytedeco"
 version = "10.2.0-$javacppVersion"
 
 repositories {
+    mavenLocal()
     mavenCentral()
     maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
 }
 
 dependencies {
     api "org.bytedeco:javacpp:$javacppVersion"
+    javacppPlatform "org.bytedeco:javacpp-platform:$javacppVersion"
     javacppPlatform "org.bytedeco:gcc:$version:linux-x86_64"
-    javacppPlatform "org.bytedeco:gcc:$version:linux-ppc64le"
 
     testRuntimeOnly "org.bytedeco:javacpp:$javacppVersion:$javacppPlatform"
     testImplementation "junit:junit:4.13.1"

build.sh

@@ -30,7 +30,7 @@ case $PLATFORM in
       --target=powerpc64le-linux-gnu \
       --prefix=$GCC_INSTALL_PREFIX \
       --enable-checking=release \
-      --enable-languages=jit \
+      --enable-languages=jit,c,c++ \
       --enable-host-shared \
       --disable-bootstrap \
       --disable-multilib \
@@ -49,7 +49,7 @@ case $PLATFORM in
     ../gcc-$GCC_VERSION/configure \
       --prefix=$GCC_INSTALL_PREFIX \
       --enable-checking=release \
-      --enable-languages=jit \
+      --enable-languages=jit,c,c++ \
       --enable-host-shared \
       --disable-bootstrap \
       --disable-multilib \

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

samples/code-generation/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id("application")
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
+}
+
+dependencies {
+    implementation("org.bytedeco:gcc-platform:10.2.0-1.5.5-SNAPSHOT")
+}
+
+application {
+    mainClass = 'DylibGenerator'
+}

samples/code-generation/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists