8348606: [lworld] Substitutability test may perform heap allocations

[liach]

Update substitutability test to use MethodHandles that access independent primitive/pointer instead heap reallocated copies of inlined values with an object header. Need long-term solution for user MethodHandle that accesses nested values in the future; hope the intrinsics can help in the future.

Testing: test/jdk/valhalla and test/hotspot/jtreg/*/valhalla, tier 1-3 tests running.

---

Progress

• Change must not contain extraneous whitespace

Issue

• JDK-8348606: [lworld] Substitutability test may perform heap allocations (Bug - P3)

Reviewing

Using git

Checkout this PR locally:
$ git fetch https://git.openjdk.org/valhalla.git pull/1364/head:pull/1364
$ git checkout pull/1364

Update a local copy of the PR:
$ git checkout pull/1364
$ git pull https://git.openjdk.org/valhalla.git pull/1364/head

Using Skara CLI tools

Checkout this PR locally:
$ git pr checkout 1364

View PR using the GUI difftool:
$ git pr show -t 1364

Using diff file

Download this PR as a diff file:
https://git.openjdk.org/valhalla/pull/1364.diff

Using Webrev

Link to Webrev Comment

[bridgekeeper]

👋 Welcome back liach! A progress list of the required criteria for merging this PR into lworld will be added to the body of your pull request. There are additional pull request commands available for use with this pull request.

[openjdk]

@liach This change is no longer ready for integration - check the PR body for details.

[mlbridge]

Webrevs

• 01: Full - Incremental (4d6a7d5c)
• 00: Full (63c46847)

[merykitty]

The reason you are seeing the failures is that you are using Unsafe incorrectly. Note this paragraph:

 * The results are undefined unless one of the following cases is true:
 * <ul>
 * <li>The offset was obtained from {@link #objectFieldOffset} on
 * the {@link java.lang.reflect.Field} of some Java field and the object
 * referred to by {@code o} is of a class compatible with that
 * field's class.
 *
 * <li>The offset and object reference {@code o} (either null or
 * non-null) were both obtained via {@link #staticFieldOffset}
 * and {@link #staticFieldBase} (respectively) from the
 * reflective {@link Field} representation of some Java field.
 *
 * <li>The object referred to by {@code o} is an array, and the offset
 * is an integer of the form {@code B+N*S}, where {@code N} is
 * a valid index into the array, and {@code B} and {@code S} are
 * the values obtained by {@link #arrayBaseOffset} and {@link
 * #arrayIndexScale} (respectively) from the array's class.  The value
 * referred to is the {@code N}<em>th</em> element of the array.
 *
 * </ul>

The wording here is albeit bad, it is not only the result that is undefined, the behaviour itself is undefined.

[liach]

Hmm, @fparain recommends this access pattern for me...