if (parentClass.isInitialized() && childClass.isInitialized() ||
if (parentClass.isResolved() && childClass.isResolved() ||
  public static byte includesType (VM_TypeReference parentType, VM_TypeReference childType) {    // First handle some cases that we can answer without needing to     // look at the type hierarchy    // NOTE: The ordering of these tests is critical!    if (childType == VM_TypeReference.NULL_TYPE) {      return parentType.isReferenceType() ? YES : NO;    }    if (parentType == VM_TypeReference.NULL_TYPE)      return NO;    if (parentType == childType)      return YES;    if (parentType == VM_TypeReference.Word && childType.isWordType())      return YES;    if (parentType.isPrimitiveType() || childType.isPrimitiveType())      return NO;    if (parentType == VM_TypeReference.JavaLangObject)      return YES;    // Oh well, we're going to have to try to actually look     // at the type hierarchy.    // IMPORTANT: We aren't allowed to cause dynamic class loading,     // so we have to roll some of this ourselves     // instead of simply calling VM_Runtime.instanceOf     // (which is allowed/required to load classes to answer the question).    try {      if (parentType.isArrayType()) {        if (childType == VM_TypeReference.JavaLangObject)          return MAYBE;        // arrays are subtypes of Object.        if (!childType.isArrayType())          return NO;        VM_TypeReference parentET = parentType.getInnermostElementType();        if (parentET == VM_TypeReference.JavaLangObject) {          int LHSDimension = parentType.getDimensionality();          int RHSDimension = childType.getDimensionality();          if ((RHSDimension > LHSDimension) ||              (RHSDimension == LHSDimension &&                childType.getInnermostElementType().isClassType()))            return YES;           else             return NO;        } else {          // parentType is [^k of something other than Object          // If dimensionalities are equal, then we can reduce           // to isAssignableWith(parentET, childET).          // If the dimensionalities are not equal then the answer is NO          if (parentType.getDimensionality() == childType.getDimensionality())            return includesType(parentET, childType.getInnermostElementType());           else             return NO;        }      } else {                    // parentType.isClassType()        if (!childType.isClassType()) {          // parentType is known to not be java.lang.Object.          return NO;        }        VM_Class childClass = (VM_Class)childType.peekResolvedType();        VM_Class parentClass = (VM_Class)parentType.peekResolvedType();        if (childClass != null && parentClass != null) {          if (parentClass.isInitialized() && childClass.isInitialized() ||              (VM.writingBootImage && parentClass.isInBootImage() && childClass.isInBootImage())) {            if (parentClass.isInterface()) {              if (VM_Runtime.isAssignableWith(parentClass, childClass)) {                return YES;              } else {                // If child is not a final class, it is                 // possible that a subclass will implement parent.                return childClass.isFinal() ? NO : MAYBE;              }            } else if (childClass.isInterface()) {              // parent is a proper class, child is an interface              return MAYBE;            } else {              // parent & child are both proper classes.              if (VM_Runtime.isAssignableWith(parentClass, childClass)) {                return YES;              }              // If child is a final class, then               // !instanceOfClass(parent, child) lets us return NO.              // However, if child is not final, then it might have               // subclasses so we can't return NO out of hand.              // But, if the reverse instanceOf is also false, then we know               // that parent and child are completely               // unrelated and we can return NO.              if (childClass.isFinal())                return NO;               else {                if (VM_Runtime.isAssignableWith(childClass, parentClass))                  return MAYBE;                 else                   return NO;              }            }          }        }        return MAYBE;      }    } catch (Throwable e) {      OPT_OptimizingCompilerException.UNREACHABLE();      return MAYBE;            // placate jikes.    }  }