Add example of C++ calling into Java

[MarkDrei]

Not sure if this the right repository.
I am looking for an example how GraalVM is used to execute C/C++ code compiled to LLVM Bitcode which then interacts with Java. The basic example from https://www.graalvm.org/latest/reference-manual/polyglot-programming/ "Start Language C" is working for me, however this only creates an array and does not interact with any custom classes.
I would like to use a class that is implemented in Java, however I fail to make this work even with a basic example. I currently get errors like this
"Access to host class graalvm.polyglot.PolyglotTestClass is not allowed or does not exist."
and I don't know whether this is due to my command line setup (classpath?) or whether I am missing some imports in my C++ code or whether I am having some other issue.
Therefore it would really help me, and hopefully others, if such an example was added here.

Update: When I run the same C code not via lli but load it from a Java class that runs inside a GraalVM, then my C code succeeds to load the Java file.
To make this more clear:
GraalVM's lli running C code which tries load a Java class -> fails. Java class is not found.
GraalVM's java running a Java class which loads the C code above -> this works.

Thanks and best regards,
Mark

[rschatz]

It should normally just work. There is nothing special about Java interop, compared to other languages.

GraalVM's lli running C code which tries load a Java class -> fails. Java class is not found.

Maybe the class is really not found? Did you put it on the classpath? I.e. lli --vm.cp=path-to-class ....

[MarkDrei]

Thanks for the answer!
The classpath was correct. That was not the issue, however I figured it out now: I was using the wrong lli. I was following this page here https://www.graalvm.org/latest/reference-manual/llvm/ and used the wrong download. There's a 'Native' and a 'JVM' download, and I was using the 'Native' one. When using the 'JVM' download my Java class can be loaded :-)

I still think that a complete example might be helpful to other, what do you think?

[rschatz]

There are a few examples in the documentation of polyglot.h, e.g. here. Unfortunately I don't think this is published anywhere in rendered form.

One little example I like to use to illustrate the interop capabilities of the LLVM runtime is using java.math.BigInteger from C:

#include <stdio.h>
#include <graalvm/llvm/polyglot.h>

struct BigInteger {
    struct BigInteger *(*pow)(int exponent);
    polyglot_value (*toString)();
};

struct BigInteger_class {
    struct BigInteger *(*valueOf)(long val);
};

POLYGLOT_DECLARE_STRUCT(BigInteger_class)

void print_polyglot_string(polyglot_value str) {
    char buffer[1024];
    polyglot_as_string(str, buffer, sizeof(buffer), "utf-8");

    // TODO better handling for overflow
    // for simplicity just put a "safety-\0" at the very end ;)
    buffer[sizeof(buffer) - 1] = '\0';

    printf("%s\n", buffer);
}

int main() {
    struct BigInteger_class *BigInteger = polyglot_as_BigInteger_class(polyglot_java_type("java.math.BigInteger"));

    struct BigInteger *two = BigInteger->valueOf(2);
    struct BigInteger *result = two->pow(100);

    print_polyglot_string(result->toString());
}

Build and run with the JVM standalone:

.../llvm-24.2.0-linux-amd64/lib/sulong/native/bin/clang  -c sample.c -o sample.o
.../llvm-24.2.0-linux-amd64/lib/sulong/native/bin/clang -lgraalvm-llvm sample.o -o sample
.../llvm-24.2.0-linux-amd64/bin/lli sample

[MarkDrei]

Thanks @rschatz , I did not see the examples in the polyglot.h

Are there any more examples which go into more advance topics and what is possible / not possible? I am thinking exceptions, lambdas, enums, generics, ...

[rschatz]

I'm afraid only very little C++ interop is currently possible. There is some support for basic things like calling virtual members and so on, but not much for the more advanced things. See oracle/graal#4665 for the PR implementing some of this, but this is pretty much stalled at the current point. See also oracle/graal#609 for a general summary of the state of what's missing (but slightly older, before the linked PR).