src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMemoryAccessProviderImpl.java

*** 21,31 ****
   * questions.
   */
  package jdk.vm.ci.hotspot;
  
  import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
- import jdk.vm.ci.common.JVMCIError;
  import jdk.vm.ci.hotspot.HotSpotVMConfig.CompressEncoding;
  import jdk.vm.ci.meta.Constant;
  import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.JavaKind;
  import jdk.vm.ci.meta.MemoryAccessProvider;
--- 21,30 ----
*** 57,67 ****
                  if (displacement == runtime.getConfig().classMirrorOffset) {
                      // Klass::_java_mirror is valid for all Klass* values
                      return true;
                  }
              } else {
!                 throw new JVMCIError("%s", metaspaceObject);
              }
          }
          return false;
      }
  
--- 56,66 ----
                  if (displacement == runtime.getConfig().classMirrorOffset) {
                      // Klass::_java_mirror is valid for all Klass* values
                      return true;
                  }
              } else {
!                 throw new IllegalArgumentException(String.valueOf(metaspaceObject));
              }
          }
          return false;
      }
  
*** 73,83 ****
              PrimitiveConstant prim = (PrimitiveConstant) base;
              if (prim.getJavaKind().isNumericInteger()) {
                  return prim.asLong();
              }
          }
!         throw new JVMCIError("%s", base);
      }
  
      private static long readRawValue(Constant baseConstant, long displacement, int bits) {
          Object base = asObject(baseConstant);
          if (base != null) {
--- 72,82 ----
              PrimitiveConstant prim = (PrimitiveConstant) base;
              if (prim.getJavaKind().isNumericInteger()) {
                  return prim.asLong();
              }
          }
!         throw new IllegalArgumentException(String.valueOf(base));
      }
  
      private static long readRawValue(Constant baseConstant, long displacement, int bits) {
          Object base = asObject(baseConstant);
          if (base != null) {
*** 89,99 ****
                  case Integer.SIZE:
                      return UNSAFE.getInt(base, displacement);
                  case Long.SIZE:
                      return UNSAFE.getLong(base, displacement);
                  default:
!                     throw new JVMCIError("%d", bits);
              }
          } else {
              long pointer = asRawPointer(baseConstant);
              switch (bits) {
                  case Byte.SIZE:
--- 88,98 ----
                  case Integer.SIZE:
                      return UNSAFE.getInt(base, displacement);
                  case Long.SIZE:
                      return UNSAFE.getLong(base, displacement);
                  default:
!                     throw new IllegalArgumentException(String.valueOf(bits));
              }
          } else {
              long pointer = asRawPointer(baseConstant);
              switch (bits) {
                  case Byte.SIZE:
*** 103,113 ****
                  case Integer.SIZE:
                      return UNSAFE.getInt(pointer + displacement);
                  case Long.SIZE:
                      return UNSAFE.getLong(pointer + displacement);
                  default:
!                     throw new JVMCIError("%d", bits);
              }
          }
      }
  
      private boolean verifyReadRawObject(Object expected, Constant base, long displacement, boolean compressed) {
--- 102,112 ----
                  case Integer.SIZE:
                      return UNSAFE.getInt(pointer + displacement);
                  case Long.SIZE:
                      return UNSAFE.getLong(pointer + displacement);
                  default:
!                     throw new IllegalArgumentException(String.valueOf(bits));
              }
          }
      }
  
      private boolean verifyReadRawObject(Object expected, Constant base, long displacement, boolean compressed) {
*** 176,186 ****
                  case Float:
                      return JavaConstant.forFloat(Float.intBitsToFloat((int) rawValue));
                  case Double:
                      return JavaConstant.forDouble(Double.longBitsToDouble(rawValue));
                  default:
!                     throw new JVMCIError("Unsupported kind: %s", kind);
              }
          } catch (NullPointerException e) {
              return null;
          }
      }
--- 175,185 ----
                  case Float:
                      return JavaConstant.forFloat(Float.intBitsToFloat((int) rawValue));
                  case Double:
                      return JavaConstant.forDouble(Double.longBitsToDouble(rawValue));
                  default:
!                     throw new IllegalArgumentException("Unsupported kind: " + kind);
              }
          } catch (NullPointerException e) {
              return null;
          }
      }