The performance of load and store operations from a heap `MemorySegment` backed by various array types varies substantially with the Vector type.

Generally, load and store operations on vector type X are performant if performed on a `MemorySegment` backed by an array of X or a byte array.

Here are some benchmark results from the micro-benchmark class `TestLoadSegmentVarious`.

```
Benchmark                                                   (size)  Mode  Cnt     Score     Error  Units
TestLoadSegmentVarious.byteVectorFromByteBackedSegment        1024  avgt   10   280.008 ?   7.251  ns/op
TestLoadSegmentVarious.byteVectorFromDoubleBackedSegment      1024  avgt   10  1304.008 ?  98.901  ns/op
TestLoadSegmentVarious.byteVectorFromIntBackedSegment         1024  avgt   10  1279.621 ? 100.008  ns/op
TestLoadSegmentVarious.doubleVectorFromByteBackedSegment      1024  avgt   10    37.281 ?   1.360  ns/op
TestLoadSegmentVarious.doubleVectorFromDoubleBackedSegment    1024  avgt   10    36.847 ?   0.130  ns/op
TestLoadSegmentVarious.doubleVectorFromIntBackedSegment       1024  avgt   10   194.195 ?  31.096  ns/op
TestLoadSegmentVarious.intVectorFromByteBackedSegment         1024  avgt   10    72.602 ?   1.768  ns/op
TestLoadSegmentVarious.intVectorFromDoubleBackedSegment       1024  avgt   10   166.851 ?   9.528  ns/op
TestLoadSegmentVarious.intVectorFromIntBackedSegment          1024  avgt   10    71.283 ?   0.507  ns/op
TestLoadSegmentVarious.scalarByteVectorFromByteSegment        1024  avgt   10  4790.084 ?  45.882  ns/op
TestLoadSegmentVarious.scalarByteVectorFromDoubleSegment      1024  avgt   10  4841.273 ? 291.962  ns/op
TestLoadSegmentVarious.scalarByteVectorFromIntSegment         1024  avgt   10  4794.028 ? 101.282  ns/op
TestLoadSegmentVarious.scalarDoubleVectorFromByteSegment      1024  avgt   10  1241.117 ?  11.603  ns/op
TestLoadSegmentVarious.scalarDoubleVectorFromDoubleSegment    1024  avgt   10  1245.752 ?  15.516  ns/op
TestLoadSegmentVarious.scalarDoubleVectorFromIntSegment       1024  avgt   10  1232.216 ?   8.365  ns/op
TestLoadSegmentVarious.scalarIntVectorFromByteSegment         1024  avgt   10  1239.146 ?  14.582  ns/op
TestLoadSegmentVarious.scalarIntVectorFromDoubleSegment       1024  avgt   10  1236.712 ?   8.063  ns/op
TestLoadSegmentVarious.scalarIntVectorFromIntSegment          1024  avgt   10  1228.656 ?   3.329  ns/op
```

A log of methods being/not being intrinsified can be obtained by running the test `IntrinsicHeapTest` and observing the standard output.  Excerpt:

```
  ** not supported: arity=0 op=load vlen=1 etype=long ismask=no
                                      @ 28   jdk.internal.vm.vector.VectorSupport::load (38 bytes)   failed to inline: failed to inline (intrinsic)
                                  @ 3   jdk.internal.misc.Unsafe::loadFence (5 bytes)   (intrinsic)
                                      @ 28   jdk.internal.vm.vector.VectorSupport::load (38 bytes)   (intrinsic)
                                  @ 3   jdk.internal.misc.Unsafe::loadFence (5 bytes)   (intrinsic)
  ** not supported: arity=0 op=load vlen=4 etype=long ismask=no
                                      @ 28   jdk.internal.vm.vector.VectorSupport::load (38 bytes)   failed to inline: failed to inline (intrinsic)
                                  @ 3   jdk.internal.misc.Unsafe::loadFence (5 bytes)   (intrinsic)
  ** not supported: arity=0 op=load vlen=8 etype=long ismask=no
                                      @ 28   jdk.internal.vm.vector.VectorSupport::load (38 bytes)   failed to inline: failed to inline (intrinsic)
                                  @ 3   jdk.internal.misc.Unsafe::loadFence (5 bytes)   (intrinsic)
                                      @ 28   jdk.internal.vm.vector.VectorSupport::load (38 bytes)   (intrinsic)
                                  @ 3   jdk.internal.misc.Unsafe::loadFence (5 bytes)   (intrinsic)
```