| /* |
| * Copyright (c) 2009, 2015, 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. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package jdk.vm.ci.meta; |
| |
| import java.lang.reflect.Array; |
| |
| //JaCoCo Exclude |
| |
| /** |
| * Denotes the basic kinds of types in CRI, including the all the Java primitive types, for example, |
| * {@link JavaKind#Int} for {@code int} and {@link JavaKind#Object} for all object types. A kind has |
| * a single character short name, a Java name, and a set of flags further describing its behavior. |
| */ |
| public enum JavaKind { |
| /** The primitive boolean kind, represented as an int on the stack. */ |
| Boolean('Z', "boolean", 1, true, java.lang.Boolean.TYPE, java.lang.Boolean.class), |
| |
| /** The primitive byte kind, represented as an int on the stack. */ |
| Byte('B', "byte", 1, true, java.lang.Byte.TYPE, java.lang.Byte.class), |
| |
| /** The primitive short kind, represented as an int on the stack. */ |
| Short('S', "short", 1, true, java.lang.Short.TYPE, java.lang.Short.class), |
| |
| /** The primitive char kind, represented as an int on the stack. */ |
| Char('C', "char", 1, true, java.lang.Character.TYPE, java.lang.Character.class), |
| |
| /** The primitive int kind, represented as an int on the stack. */ |
| Int('I', "int", 1, true, java.lang.Integer.TYPE, java.lang.Integer.class), |
| |
| /** The primitive float kind. */ |
| Float('F', "float", 1, false, java.lang.Float.TYPE, java.lang.Float.class), |
| |
| /** The primitive long kind. */ |
| Long('J', "long", 2, false, java.lang.Long.TYPE, java.lang.Long.class), |
| |
| /** The primitive double kind. */ |
| Double('D', "double", 2, false, java.lang.Double.TYPE, java.lang.Double.class), |
| |
| /** The Object kind, also used for arrays. */ |
| Object('A', "Object", 1, false, null, null), |
| |
| /** The void kind. */ |
| Void('V', "void", 0, false, java.lang.Void.TYPE, java.lang.Void.class), |
| |
| /** The non-type. */ |
| Illegal('-', "illegal", 0, false, null, null); |
| |
| private final char typeChar; |
| private final String javaName; |
| private final boolean isStackInt; |
| private final Class<?> primitiveJavaClass; |
| private final Class<?> boxedJavaClass; |
| private final int slotCount; |
| |
| JavaKind(char typeChar, String javaName, int slotCount, boolean isStackInt, Class<?> primitiveJavaClass, Class<?> boxedJavaClass) { |
| this.typeChar = typeChar; |
| this.javaName = javaName; |
| this.slotCount = slotCount; |
| this.isStackInt = isStackInt; |
| this.primitiveJavaClass = primitiveJavaClass; |
| this.boxedJavaClass = boxedJavaClass; |
| assert primitiveJavaClass == null || javaName.equals(primitiveJavaClass.getName()); |
| } |
| |
| /** |
| * Returns the number of stack slots occupied by this kind according to the Java bytecodes |
| * specification. |
| */ |
| public int getSlotCount() { |
| return this.slotCount; |
| } |
| |
| /** |
| * Returns whether this kind occupied two stack slots. |
| */ |
| public boolean needsTwoSlots() { |
| return this.slotCount == 2; |
| } |
| |
| /** |
| * Returns the name of the kind as a single upper case character. For the void and primitive |
| * kinds, this is the <i>FieldType</i> term in |
| * <a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2-200"> |
| * table 4.3-A</a> of the JVM Specification. For {@link #Object}, the character {@code 'A'} is |
| * returned and for {@link #Illegal}, {@code '-'} is returned. |
| */ |
| public char getTypeChar() { |
| return typeChar; |
| } |
| |
| /** |
| * Returns the name of this kind which will also be it Java programming language name if it is |
| * {@linkplain #isPrimitive() primitive} or {@code void}. |
| */ |
| public String getJavaName() { |
| return javaName; |
| } |
| |
| /** |
| * Checks whether this type is a Java primitive type. |
| * |
| * @return {@code true} if this is {@link #Boolean}, {@link #Byte}, {@link #Char}, |
| * {@link #Short}, {@link #Int}, {@link #Long}, {@link #Float}, {@link #Double}, or |
| * {@link #Void}. |
| */ |
| public boolean isPrimitive() { |
| return primitiveJavaClass != null; |
| } |
| |
| /** |
| * Returns the kind that represents this kind when on the Java operand stack. |
| * |
| * @return the kind used on the operand stack |
| */ |
| public JavaKind getStackKind() { |
| if (isStackInt) { |
| return Int; |
| } |
| return this; |
| } |
| |
| /** |
| * Checks whether this type is a Java primitive type representing an integer number. |
| * |
| * @return {@code true} if the stack kind is {@link #Int} or {@link #Long}. |
| */ |
| public boolean isNumericInteger() { |
| return isStackInt || this == JavaKind.Long; |
| } |
| |
| /** |
| * Checks whether this type is a Java primitive type representing an unsigned number. |
| * |
| * @return {@code true} if the kind is {@link #Boolean} or {@link #Char}. |
| */ |
| public boolean isUnsigned() { |
| return this == JavaKind.Boolean || this == JavaKind.Char; |
| } |
| |
| /** |
| * Checks whether this type is a Java primitive type representing a floating point number. |
| * |
| * @return {@code true} if this is {@link #Float} or {@link #Double}. |
| */ |
| public boolean isNumericFloat() { |
| return this == JavaKind.Float || this == JavaKind.Double; |
| } |
| |
| /** |
| * Checks whether this represent an Object of some sort. |
| * |
| * @return {@code true} if this is {@link #Object}. |
| */ |
| public boolean isObject() { |
| return this == JavaKind.Object; |
| } |
| |
| /** |
| * Returns the kind corresponding to the Java type string. |
| * |
| * @param typeString the Java type string |
| * @return the kind |
| */ |
| public static JavaKind fromTypeString(String typeString) { |
| assert typeString.length() > 0; |
| final char first = typeString.charAt(0); |
| if (first == '[' || first == 'L') { |
| return JavaKind.Object; |
| } |
| return JavaKind.fromPrimitiveOrVoidTypeChar(first); |
| } |
| |
| /** |
| * Returns the kind of a word given the size of a word in bytes. |
| * |
| * @param wordSizeInBytes the size of a word in bytes |
| * @return the kind representing a word value |
| */ |
| public static JavaKind fromWordSize(int wordSizeInBytes) { |
| if (wordSizeInBytes == 8) { |
| return JavaKind.Long; |
| } else { |
| assert wordSizeInBytes == 4 : "Unsupported word size!"; |
| return JavaKind.Int; |
| } |
| } |
| |
| /** |
| * Returns the kind from the character describing a primitive or void. |
| * |
| * @param ch the character for a void or primitive kind as returned by {@link #getTypeChar()} |
| * @return the kind |
| */ |
| public static JavaKind fromPrimitiveOrVoidTypeChar(char ch) { |
| switch (ch) { |
| case 'Z': |
| return Boolean; |
| case 'C': |
| return Char; |
| case 'F': |
| return Float; |
| case 'D': |
| return Double; |
| case 'B': |
| return Byte; |
| case 'S': |
| return Short; |
| case 'I': |
| return Int; |
| case 'J': |
| return Long; |
| case 'V': |
| return Void; |
| } |
| throw new IllegalArgumentException("unknown primitive or void type character: " + ch); |
| } |
| |
| /** |
| * Returns the Kind representing the given Java class. |
| * |
| * @param klass the class |
| * @return the kind |
| */ |
| public static JavaKind fromJavaClass(Class<?> klass) { |
| if (klass == Boolean.primitiveJavaClass) { |
| return Boolean; |
| } else if (klass == Byte.primitiveJavaClass) { |
| return Byte; |
| } else if (klass == Short.primitiveJavaClass) { |
| return Short; |
| } else if (klass == Char.primitiveJavaClass) { |
| return Char; |
| } else if (klass == Int.primitiveJavaClass) { |
| return Int; |
| } else if (klass == Long.primitiveJavaClass) { |
| return Long; |
| } else if (klass == Float.primitiveJavaClass) { |
| return Float; |
| } else if (klass == Double.primitiveJavaClass) { |
| return Double; |
| } else if (klass == Void.primitiveJavaClass) { |
| return Void; |
| } else { |
| return Object; |
| } |
| } |
| |
| /** |
| * Returns the Java class representing this kind. |
| * |
| * @return the Java class |
| */ |
| public Class<?> toJavaClass() { |
| return primitiveJavaClass; |
| } |
| |
| /** |
| * Returns the Java class for instances of boxed values of this kind. |
| * |
| * @return the Java class |
| */ |
| public Class<?> toBoxedJavaClass() { |
| return boxedJavaClass; |
| } |
| |
| /** |
| * Converts this value type to a string. |
| */ |
| @Override |
| public String toString() { |
| return javaName; |
| } |
| |
| /** |
| * Marker interface for types that should be {@linkplain JavaKind#format(Object) formatted} with |
| * their {@link Object#toString()} value. Calling {@link Object#toString()} on other objects |
| * poses a security risk because it can potentially call user code. |
| */ |
| public interface FormatWithToString { |
| } |
| |
| /** |
| * Classes for which invoking {@link Object#toString()} does not run user code. |
| */ |
| private static boolean isToStringSafe(Class<?> c) { |
| return c == Boolean.class || c == Byte.class || c == Character.class || c == Short.class || c == Integer.class || c == Float.class || c == Long.class || c == Double.class; |
| } |
| |
| /** |
| * Gets a formatted string for a given value of this kind. |
| * |
| * @param value a value of this kind |
| * @return a formatted string for {@code value} based on this kind |
| */ |
| public String format(Object value) { |
| if (isPrimitive()) { |
| assert isToStringSafe(value.getClass()); |
| return value.toString(); |
| } else { |
| if (value == null) { |
| return "null"; |
| } else { |
| if (value instanceof String) { |
| String s = (String) value; |
| if (s.length() > 50) { |
| return "String:\"" + s.substring(0, 30) + "...\""; |
| } else { |
| return "String:\"" + s + '"'; |
| } |
| } else if (value instanceof JavaType) { |
| return "JavaType:" + ((JavaType) value).toJavaName(); |
| } else if (value instanceof Enum) { |
| return MetaUtil.getSimpleName(value.getClass(), true) + ":" + ((Enum<?>) value).name(); |
| } else if (value instanceof FormatWithToString) { |
| return MetaUtil.getSimpleName(value.getClass(), true) + ":" + String.valueOf(value); |
| } else if (value instanceof Class<?>) { |
| return "Class:" + ((Class<?>) value).getName(); |
| } else if (isToStringSafe(value.getClass())) { |
| return value.toString(); |
| } else if (value.getClass().isArray()) { |
| return formatArray(value); |
| } else { |
| return MetaUtil.getSimpleName(value.getClass(), true) + "@" + System.identityHashCode(value); |
| } |
| } |
| } |
| } |
| |
| private static final int MAX_FORMAT_ARRAY_LENGTH = 5; |
| |
| private static String formatArray(Object array) { |
| Class<?> componentType = array.getClass().getComponentType(); |
| assert componentType != null; |
| int arrayLength = Array.getLength(array); |
| StringBuilder buf = new StringBuilder(MetaUtil.getSimpleName(componentType, true)).append('[').append(arrayLength).append("]{"); |
| int length = Math.min(MAX_FORMAT_ARRAY_LENGTH, arrayLength); |
| boolean primitive = componentType.isPrimitive(); |
| for (int i = 0; i < length; i++) { |
| if (primitive) { |
| buf.append(Array.get(array, i)); |
| } else { |
| Object o = ((Object[]) array)[i]; |
| buf.append(JavaKind.Object.format(o)); |
| } |
| if (i != length - 1) { |
| buf.append(", "); |
| } |
| } |
| if (arrayLength != length) { |
| buf.append(", ..."); |
| } |
| return buf.append('}').toString(); |
| } |
| |
| /** |
| * Gets the minimum value that can be represented as a value of this kind. |
| * |
| * @return the minimum value represented as a {@code long} |
| */ |
| public long getMinValue() { |
| switch (this) { |
| case Boolean: |
| return 0; |
| case Byte: |
| return java.lang.Byte.MIN_VALUE; |
| case Char: |
| return java.lang.Character.MIN_VALUE; |
| case Short: |
| return java.lang.Short.MIN_VALUE; |
| case Int: |
| return java.lang.Integer.MIN_VALUE; |
| case Long: |
| return java.lang.Long.MIN_VALUE; |
| case Float: |
| return java.lang.Float.floatToRawIntBits(java.lang.Float.MIN_VALUE); |
| case Double: |
| return java.lang.Double.doubleToRawLongBits(java.lang.Double.MIN_VALUE); |
| default: |
| throw new IllegalArgumentException("illegal call to minValue on " + this); |
| } |
| } |
| |
| /** |
| * Gets the maximum value that can be represented as a value of this kind. |
| * |
| * @return the maximum value represented as a {@code long} |
| */ |
| public long getMaxValue() { |
| switch (this) { |
| case Boolean: |
| return 1; |
| case Byte: |
| return java.lang.Byte.MAX_VALUE; |
| case Char: |
| return java.lang.Character.MAX_VALUE; |
| case Short: |
| return java.lang.Short.MAX_VALUE; |
| case Int: |
| return java.lang.Integer.MAX_VALUE; |
| case Long: |
| return java.lang.Long.MAX_VALUE; |
| case Float: |
| return java.lang.Float.floatToRawIntBits(java.lang.Float.MAX_VALUE); |
| case Double: |
| return java.lang.Double.doubleToRawLongBits(java.lang.Double.MAX_VALUE); |
| default: |
| throw new IllegalArgumentException("illegal call to maxValue on " + this); |
| } |
| } |
| |
| /** |
| * Number of bytes that are necessary to represent a value of this kind. |
| * |
| * @return the number of bytes |
| */ |
| public int getByteCount() { |
| if (this == Boolean) { |
| return 1; |
| } else { |
| return getBitCount() >> 3; |
| } |
| } |
| |
| /** |
| * Number of bits that are necessary to represent a value of this kind. |
| * |
| * @return the number of bits |
| */ |
| public int getBitCount() { |
| switch (this) { |
| case Boolean: |
| return 1; |
| case Byte: |
| return 8; |
| case Char: |
| case Short: |
| return 16; |
| case Float: |
| return 32; |
| case Int: |
| return 32; |
| case Double: |
| return 64; |
| case Long: |
| return 64; |
| default: |
| throw new IllegalArgumentException("illegal call to bits on " + this); |
| } |
| } |
| } |
