*** old/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java	Thu Mar 28 11:23:54 2019
--- new/src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/HotSpotMetaAccessProvider.java	Thu Mar 28 11:23:54 2019

*** 1,7 ****
--- 1,7 ----
  /*
!  * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
!  * Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 20,33 ****
--- 20,29 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package jdk.vm.ci.hotspot;
  
  import static jdk.vm.ci.hotspot.HotSpotResolvedObjectTypeImpl.fromObjectClass;
  import static jdk.vm.ci.hotspot.UnsafeAccess.UNSAFE;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.Executable;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.Objects;
  

*** 41,50 ****
--- 37,48 ----
  import jdk.vm.ci.meta.ResolvedJavaField;
  import jdk.vm.ci.meta.ResolvedJavaMethod;
  import jdk.vm.ci.meta.ResolvedJavaType;
  import jdk.vm.ci.meta.Signature;
  import jdk.vm.ci.meta.SpeculationLog;
+ import jdk.vm.ci.meta.SpeculationLog.NoSpeculationReason;
+ import jdk.vm.ci.meta.SpeculationLog.Speculation;
  
  // JaCoCo Exclude
  
  /**
   * HotSpot implementation of {@link MetaAccessProvider}.

*** 85,108 ****
--- 83,105 ----
  
      @Override
      public ResolvedJavaField lookupJavaField(Field reflectionField) {
          Class<?> fieldHolder = reflectionField.getDeclaringClass();
  
!         HotSpotResolvedObjectType holder = fromObjectClass(fieldHolder);
!         HotSpotResolvedJavaType holder = runtime.fromClass(fieldHolder);
+         assert holder != null : fieldHolder;
+         ResolvedJavaField[] fields;
          if (Modifier.isStatic(reflectionField.getModifiers())) {
!             final long offset = UNSAFE.staticFieldOffset(reflectionField);
              for (ResolvedJavaField field : holder.getStaticFields()) {
                  if (offset == ((HotSpotResolvedJavaField) field).getOffset()) {
                      return field;
                  }
              }
!             fields = holder.getStaticFields();
          } else {
!             final long offset = UNSAFE.objectFieldOffset(reflectionField);
              for (ResolvedJavaField field : holder.getInstanceFields(false)) {
                  if (offset == ((HotSpotResolvedJavaField) field).getOffset()) {
                      return field;
!             fields = holder.getInstanceFields(false);
          }
+         ResolvedJavaType fieldType = lookupJavaType(reflectionField.getType());
+         for (ResolvedJavaField field : fields) {
+             if (reflectionField.getName().equals(field.getName()) && field.getType().equals(fieldType)) {
+                 assert Modifier.isStatic(reflectionField.getModifiers()) == field.isStatic();
+                 return field;
              }
          }
  
          throw new JVMCIError("unresolved field %s", reflectionField);
      }

*** 145,167 ****
--- 142,166 ----
          HotSpotVMConfig config = runtime.getConfig();
          return ((~constant.asInt()) >> config.deoptimizationDebugIdShift) & intMaskRight(config.deoptimizationDebugIdBits);
      }
  
      @Override
-     public JavaConstant encodeSpeculation(SpeculationLog.Speculation speculation) {
-         if (speculation.getReason() instanceof SpeculationLog.NoSpeculationReason) {
              return JavaConstant.LONG_0;
          }
          return ((HotSpotSpeculationLog.HotSpotSpeculation) speculation).getEncoding();
      }
  
      @Override
-     public SpeculationLog.Speculation decodeSpeculation(JavaConstant constant, SpeculationLog speculationLog) {
          if (constant.equals(JavaConstant.LONG_0)) {
              return SpeculationLog.NO_SPECULATION;
          }
          assert speculationLog != null : "Must have a speculation log";
+         if (speculationLog == null) {
+             throw new IllegalArgumentException("A speculation log is required to decode the speculation denoted by " + constant);
+         }
          return speculationLog.lookupSpeculation(constant);
      }
  
      public int convertDeoptAction(DeoptimizationAction action) {
          HotSpotVMConfig config = runtime.getConfig();

*** 301,315 ****
--- 300,314 ----
  
              if (lookupJavaType == null) {
                  return 0;
              } else {
                  if (lookupJavaType.isArray()) {
!                     int length = Array.getLength(((HotSpotObjectConstantImpl) constant).object());
!                     int length = runtime.getHostJVMCIBackend().getConstantReflection().readArrayLength(constant);
                      ResolvedJavaType elementType = lookupJavaType.getComponentType();
                      JavaKind elementKind = elementType.getJavaKind();
!                     final int headerSize = runtime.getArrayBaseOffset(elementKind);
!                     int sizeOfElement = runtime.getArrayIndexScale(elementKind);
                      int log2ElementSize = CodeUtil.log2(sizeOfElement);
                      return computeArrayAllocationSize(length, headerSize, log2ElementSize);
                  }
                  return lookupJavaType.instanceSize();
              }