RFR: 8289094: [JVMCI] reduce JNI overhead and other VM rounds trips in JVMCI

[Doug Simon]

The interface between HotSpot and libjvmci is implemented via JNI. Every time HotSpot C++ code needs to access libjvmci objects, it requires 4 VM transitions:
1. HotSpot: VM to native (`_thread_in_vm` -> `_thread_in_native`)
2. SVM: Native to VM (enter SVM)
3. SVM: VM to native (exit SVM)
4. HotSpot: Native to VM (`_thread_in_native` -> `_thread_in_vm`)

When processing a `HotSpotCompiledCode` object during code installation (i.e. `CodeInstaller::install`), the overhead of all these transitions is significant.
This PR changes the way code installation is done by serializing a `HotSpotCompiledCode` object to a byte array (in malloc'ed memory). The C++ code then deserializes this format to install the final code in the code cache. The bulk of this change is in `jdk.vm.ci.hotspot.HotSpotCompiledCodeStream` and `jvmciCodeInstaller.cpp`.

There are other smaller changes to reduce JNI overhead included in this PR:
* Pass raw VM values alongside JVMCI wrapper objects to the VM to avoid JNI upcall to unbox in C++. For example, the [getBytecode](https://github.com/openjdk/jdk/blob/33369719b2e39bddd4a1b7f300f36506306b03fa/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/CompilerToVM.java#L125) native method passed a `HotSpotResolvedJavaMethodImpl` to the VM and the VM then subsequently needs a JNI upcall to extract the `Method*` value from the `HotSpotResolvedJavaMethodImpl.methodHandle` field. With PR, `getBytecode` now passes an argument pair (i.e. `getBytecode(HotSpotResolvedJavaMethodImpl method, long methodPointer);`) that removes the unboxing upcall. This is done for all JVMCI objects that wrap a C++ object pointer. The box object is still passed as it protects the validity of the C++ pointer value.
* Cache HotSpotConstantPool holder in [`HotSpotConstantPool.getHolder()`](https://github.com/openjdk/jdk/blob/33369719b2e39bddd4a1b7f300f36506306b03fa/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotConstantPool.java#L236).
* Remove VM round trip for converting a `Klass*` value to a `ResolvedJavaType`.
* Avoid eager `String` creation in `JVMCIEnv::get_jvmci_type`.

This change is primarily in JVMCI-only code. It has been extensively tested in GraalVM on JDK 17. On the [octane](https://developers.google.com/octane) JavaScript benchmark, this PR reduces total time spent by GraalVM EE in JVMCI code installation from 648 s to 382 s.

-------------

Commit messages:
 - reduce JNI overhead and other VM rounds trips in JVMCI

Changes: https://git.openjdk.org/jdk/pull/9305/files
 Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=9305&range=00
  Issue: https://bugs.openjdk.org/browse/JDK-8289094
  Stats: 4488 lines in 53 files changed: 2492 ins; 992 del; 1004 mod
  Patch: https://git.openjdk.org/jdk/pull/9305.diff
  Fetch: git fetch https://git.openjdk.org/jdk pull/9305/head:pull/9305

PR: https://git.openjdk.org/jdk/pull/9305