2

Background

I'm currently writing a JVM in C# for purely academic purposes (and maybe to build a mixed .NET and Java/Scala application in the future).

Context

I write the simple JAVA class:

public class test
{
    public static String hello_world(int i)
    {
        return "Hello " + i + " World!";
    }
}

And compile it into test.class. When I decompile it with my decompiler (which I have written as part of the JVM), I see the following instructions for this method:

iload_0
invokedynamic 2
areturn

When looking inside the constant pool for the constant at index 2, I see an InvokeDynamic-Constant entry with the following data:

makeConcatWithConstants : (I)Ljava/lang/String;

Which makes sense, I guess (I am more a .NET-user than a JAVA-user).

When executing my method hello_world with the parameter 1, I have the following Stack before executing invokedynamic 2:

----TOP---
0x00000001
--BOTTOM--

Question

My question is: How do I use invokedynamic?
I cannot resolve the method makeConcatWithConstants, as the InvokeDynamic-Constant does not give me any hint, where makeConcatWithConstants might be located (see documentation).
Neither does the stack contain a reference to the heap, indicating which instance type the method makeConcatWithConstants could be associated with.

I read through the invokedynamic docs but I do not understand it (Maybe I'm to much "damaged" by the .NET-Framework).

Can somebody point me to some example about what is going on under the JVM's hood when executing these three instructions? (What the callee of invokedynamic expects etc.)?

I already implemented invokestatic in my JVM ... but I am currently unable to understand invokedynamic.

unknown6656
  • 2,765
  • 2
  • 36
  • 52
  • 3
    Interesting. I didn't know that modern Java compilers use `invokedynamic` to optimize string concatenation. That is brilliant! – Jörg W Mittag Nov 04 '18 at 10:25
  • @JörgWMittag https://stackoverflow.com/questions/46512888/how-is-string-concatenation-implemented-in-java-9 – Thilo Nov 04 '18 at 11:28
  • Hmm. I'd consider [the `invokedynamic` docs](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokedynamic), you've linked yourself, quiet exhaustive, especially when you also follow the link. Perhaps, it helps reading [the package documentation](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/invoke/package-summary.html) in addition. – Holger Nov 04 '18 at 14:24
  • 2
    As an additional note, when you are going to process class files, which are clearly compiled with Java 9 or newer, you should not keep using Java 7's documentation. See [Java 11's JVM specification](https://docs.oracle.com/javase/specs/jvms/se11/html/)... – Holger Nov 04 '18 at 14:31
  • @Holger: I know that the docs are quite exhaustive, however, I personally have trouble following them to their fullest extend, as I come from the .NET-world. Thank you for referring me to the JVMv11 docs, which would of course explain why I had some trouble parsing newer `.class` files when using the old specifications .... – unknown6656 Nov 04 '18 at 16:05

1 Answers1

4

The idea of invokedynamic is; When first encountering this bytecode call a bootstrap method which creates a Callsite object that links to the actual method that needs to be invoked.

In practice this often means that you dynamically create the implementation for the call.

If you look at your program with javap -v test, you will see at the bottom a BootstrapMethods attribute:

BootstrapMethods:
  0: #15 REF_invokeStatic java/lang/invoke/StringConcatFactory.makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #16 Hello \u0001 World!

Where you can see that the bootstrap method for this particular callsite is located in StringConcatFactory

The Method arguments are the set of constant arguments.

The leading arguments of Lookup, String and MethodType are respectively; a lookup object with the same priveledges as the callsite, some name, and the type of the callsite. The first of these needs to be provided by the VM at runtime , and the latter 2 are provided by the invokedynamic constant pool entry in the form of a name and type:

#2 = InvokeDynamic      #0:#17         // #0:makeConcatWithConstants:(I)Ljava/lang/String;

So to implement this bytecode you have to have some machinery in place to create the lookup object, and then be able to call the bootstrap method. After that you can call dynamicInvoker() on the returned Callsite object, which gives you a MethodHandle that you should then cache for this particular callsite and then (finally) invoke.

If you want to look at how this is implemented in OpenJDK you can find the implementation here: http://hg.openjdk.java.net/jdk/jdk/file/tip/src/hotspot/share/interpreter/bytecodeInterpreter.cpp#l2446

I'm guessing this is probably too tricky at this early stage of the project, so for now it might be easier to compile your program with -XDstringConcat=inline, since that uses the legacy StringBuilder concatenation, which should be simpler to implement.

Jorn Vernee
  • 31,735
  • 4
  • 76
  • 93
  • Thank you very much for your insightful answer! I will try to implement this callsite-building and come back here to report on my future progress/errors/questions. – unknown6656 Nov 04 '18 at 11:24
  • 3
    It is essentially a user-programmable version of `invokevirtual`. In fact, once you have `invokedynamic`, you should be able to implement all the over `invoke*` bytecodes on top of it. `invokedynamic` was introduced to allow implementors of other languages than Java to enjoy the same kinds of performance for their dynamic dispatch that Java enjoys. – Jörg W Mittag Nov 04 '18 at 12:29
  • There is one case where you can't use `invokedynamic` instead of one of the other `invoke*` bytecodes: Calling the super constructor in a constructor. This has to be a `invokespecial` instruction. – Johannes Kuhn Sep 02 '19 at 09:01