1 /*
   2  * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package jdk.vm.ci.hotspot;
  24 
  25 import static java.util.Objects.requireNonNull;
  26 
  27 import java.lang.annotation.Annotation;
  28 import java.lang.reflect.Array;
  29 import java.lang.reflect.Modifier;
  30 
  31 import jdk.vm.ci.common.JVMCIError;
  32 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
  33 import jdk.vm.ci.meta.JavaConstant;
  34 import jdk.vm.ci.meta.JavaKind;
  35 import jdk.vm.ci.meta.JavaType;
  36 import jdk.vm.ci.meta.ResolvedJavaField;
  37 import jdk.vm.ci.meta.ResolvedJavaMethod;
  38 import jdk.vm.ci.meta.ResolvedJavaType;
  39 
  40 /**
  41  * Implementation of {@link JavaType} for primitive HotSpot types.
  42  */
  43 public final class HotSpotResolvedPrimitiveType extends HotSpotResolvedJavaType implements HotSpotProxified {
  44 
  45     private final JavaKind kind;
  46 
  47     /**
  48      * Creates the JVMCI mirror for a primitive {@link JavaKind}.
  49      *
  50      * <p>
  51      * <b>NOTE</b>: Creating an instance of this class does not install the mirror for the
  52      * {@link Class} type. Use {@link HotSpotJVMCIRuntimeProvider#fromClass(Class)} instead.
  53      * </p>
  54      *
  55      * @param kind the Kind to create the mirror for
  56      */
  57     public HotSpotResolvedPrimitiveType(JavaKind kind) {
  58         super(String.valueOf(Character.toUpperCase(kind.getTypeChar())));
  59         this.kind = kind;
  60         assert mirror().isPrimitive() : mirror() + " not a primitive type";
  61     }
  62 
  63     @Override
  64     public int getModifiers() {
  65         return Modifier.ABSTRACT | Modifier.FINAL | Modifier.PUBLIC;
  66     }
  67 
  68     @Override
  69     public HotSpotResolvedObjectTypeImpl getArrayClass() {
  70         if (kind == JavaKind.Void) {
  71             return null;
  72         }
  73         Class<?> javaArrayMirror = Array.newInstance(mirror(), 0).getClass();
  74         return HotSpotResolvedObjectTypeImpl.fromObjectClass(javaArrayMirror);
  75     }
  76 
  77     public ResolvedJavaType getElementalType() {
  78         return this;
  79     }
  80 
  81     @Override
  82     public ResolvedJavaType getComponentType() {
  83         return null;
  84     }
  85 
  86     @Override
  87     public ResolvedJavaType asExactType() {
  88         return this;
  89     }
  90 
  91     @Override
  92     public ResolvedJavaType getSuperclass() {
  93         return null;
  94     }
  95 
  96     @Override
  97     public ResolvedJavaType[] getInterfaces() {
  98         return new ResolvedJavaType[0];
  99     }
 100 
 101     @Override
 102     public ResolvedJavaType getSingleImplementor() {
 103         throw new JVMCIError("Cannot call getSingleImplementor() on a non-interface type: %s", this);
 104     }
 105 
 106     @Override
 107     public ResolvedJavaType findLeastCommonAncestor(ResolvedJavaType otherType) {
 108         return null;
 109     }
 110 
 111     @Override
 112     public AssumptionResult<Boolean> hasFinalizableSubclass() {
 113         return new AssumptionResult<>(false);
 114     }
 115 
 116     @Override
 117     public boolean hasFinalizer() {
 118         return false;
 119     }
 120 
 121     @Override
 122     public boolean isArray() {
 123         return false;
 124     }
 125 
 126     @Override
 127     public boolean isPrimitive() {
 128         return true;
 129     }
 130 
 131     @Override
 132     public boolean isInitialized() {
 133         return true;
 134     }
 135 
 136     public boolean isLinked() {
 137         return true;
 138     }
 139 
 140     @Override
 141     public boolean isInstance(JavaConstant obj) {
 142         return false;
 143     }
 144 
 145     @Override
 146     public boolean isInstanceClass() {
 147         return false;
 148     }
 149 
 150     @Override
 151     public boolean isInterface() {
 152         return false;
 153     }
 154 
 155     @Override
 156     public boolean isAssignableFrom(ResolvedJavaType other) {
 157         assert other != null;
 158         return other.equals(this);
 159     }
 160 
 161     @Override
 162     public JavaKind getJavaKind() {
 163         return kind;
 164     }
 165 
 166     @Override
 167     public boolean isJavaLangObject() {
 168         return false;
 169     }
 170 
 171     @Override
 172     public ResolvedJavaMethod resolveMethod(ResolvedJavaMethod method, ResolvedJavaType callerType) {
 173         return null;
 174     }
 175 
 176     @Override
 177     public String toString() {
 178         return "HotSpotResolvedPrimitiveType<" + kind + ">";
 179     }
 180 
 181     @Override
 182     public AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype() {
 183         return new AssumptionResult<>(this);
 184     }
 185 
 186     @Override
 187     public AssumptionResult<ResolvedJavaMethod> findUniqueConcreteMethod(ResolvedJavaMethod method) {
 188         return null;
 189     }
 190 
 191     @Override
 192     public ResolvedJavaField[] getInstanceFields(boolean includeSuperclasses) {
 193         return new ResolvedJavaField[0];
 194     }
 195 
 196     @Override
 197     public ResolvedJavaField[] getStaticFields() {
 198         return new ResolvedJavaField[0];
 199     }
 200 
 201     @Override
 202     public Annotation[] getAnnotations() {
 203         return new Annotation[0];
 204     }
 205 
 206     @Override
 207     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
 208         return null;
 209     }
 210 
 211     @Override
 212     public ResolvedJavaType resolve(ResolvedJavaType accessingClass) {
 213         requireNonNull(accessingClass);
 214         return this;
 215     }
 216 
 217     @Override
 218     public void initialize() {
 219     }
 220 
 221     @Override
 222     public ResolvedJavaField findInstanceFieldWithOffset(long offset, JavaKind expectedType) {
 223         return null;
 224     }
 225 
 226     @Override
 227     public String getSourceFileName() {
 228         throw JVMCIError.unimplemented();
 229     }
 230 
 231     @Override
 232     public Class<?> mirror() {
 233         return kind.toJavaClass();
 234     }
 235 
 236     @Override
 237     public boolean isLocal() {
 238         return false;
 239     }
 240 
 241     @Override
 242     public boolean isMember() {
 243         return false;
 244     }
 245 
 246     @Override
 247     public ResolvedJavaType getEnclosingType() {
 248         return null;
 249     }
 250 
 251     @Override
 252     public ResolvedJavaMethod[] getDeclaredConstructors() {
 253         return new ResolvedJavaMethod[0];
 254     }
 255 
 256     @Override
 257     public ResolvedJavaMethod[] getDeclaredMethods() {
 258         return new ResolvedJavaMethod[0];
 259     }
 260 
 261     @Override
 262     public ResolvedJavaMethod getClassInitializer() {
 263         return null;
 264     }
 265 
 266     @Override
 267     public boolean isTrustedInterfaceType() {
 268         return false;
 269     }
 270 
 271     @Override
 272     public boolean isCloneableWithAllocation() {
 273         return false;
 274     }
 275 }