コード例 #1
0
  @Override
  public long getMemorySize(Constant constant) {
    if (constant.getKind() == Kind.Object) {
      HotSpotResolvedObjectType lookupJavaType =
          (HotSpotResolvedObjectType) this.lookupJavaType(constant);

      if (lookupJavaType == null) {
        return 0;
      } else {
        if (lookupJavaType.isArray()) {
          // TODO(tw): Add compressed pointer support.
          int length = Array.getLength(HotSpotObjectConstant.asObject(constant));
          ResolvedJavaType elementType = lookupJavaType.getComponentType();
          Kind elementKind = elementType.getKind();
          final int headerSize = HotSpotGraalRuntime.getArrayBaseOffset(elementKind);
          int sizeOfElement = HotSpotGraalRuntime.runtime().getTarget().getSizeInBytes(elementKind);
          int alignment = HotSpotGraalRuntime.runtime().getTarget().wordSize;
          int log2ElementSize = CodeUtil.log2(sizeOfElement);
          return NewObjectSnippets.computeArrayAllocationSize(
              length, alignment, headerSize, log2ElementSize);
        }
        return lookupJavaType.instanceSize();
      }
    } else {
      return constant.getKind().getByteCount();
    }
  }
コード例 #2
0
 public ResolvedJavaType lookupJavaType(Constant constant) {
   if (constant.isNull() || !(constant instanceof HotSpotObjectConstant)) {
     return null;
   }
   Object o = HotSpotObjectConstant.asObject(constant);
   return HotSpotResolvedObjectType.fromClass(o.getClass());
 }
コード例 #3
0
  public ResolvedJavaField lookupJavaField(Field reflectionField) {
    String name = reflectionField.getName();
    Class<?> fieldHolder = reflectionField.getDeclaringClass();
    Class<?> fieldType = reflectionField.getType();
    // java.lang.reflect.Field's modifiers should be enough here since VM internal modifier bits
    // are not used (yet).
    final int modifiers = reflectionField.getModifiers();
    final long offset =
        Modifier.isStatic(modifiers)
            ? unsafe.staticFieldOffset(reflectionField)
            : unsafe.objectFieldOffset(reflectionField);

    ResolvedJavaType holder = HotSpotResolvedObjectType.fromClass(fieldHolder);
    ResolvedJavaType type = HotSpotResolvedObjectType.fromClass(fieldType);

    if (offset != -1) {
      HotSpotResolvedObjectType resolved = (HotSpotResolvedObjectType) holder;
      return resolved.createField(name, type, offset, modifiers);
    } else {
      throw GraalInternalError.shouldNotReachHere("unresolved field " + reflectionField);
    }
  }
コード例 #4
0
 public ResolvedJavaType lookupJavaType(Class<?> clazz) {
   if (clazz == null) {
     throw new IllegalArgumentException("Class parameter was null");
   }
   return HotSpotResolvedObjectType.fromClass(clazz);
 }