--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Kind.java	Fri Sep 07 11:10:48 2012 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Kind.java	Fri Sep 07 12:12:47 2012 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2012, 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
@@ -22,59 +22,61 @@
  */
 package com.oracle.graal.api.meta;
 
-import static com.oracle.graal.api.meta.Kind.Flags.*;
-
 import java.lang.reflect.*;
 
 import sun.misc.*;
 
 /**
- * Denotes the basic kinds of types in CRI, including the all the Java primitive types,
- * for example, {@link Kind#Int} for {@code int} and {@link Kind#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.
+ * Denotes the basic kinds of types in CRI, including the all the Java primitive types, for example, {@link Kind#Int}
+ * for {@code int} and {@link Kind#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 Kind {
-    Boolean('z', "boolean", PRIMITIVE | STACK_INT),
-    Byte   ('b', "byte",    PRIMITIVE | STACK_INT),
-    Short  ('s', "short",   PRIMITIVE | STACK_INT),
-    Char   ('c', "char",    PRIMITIVE | STACK_INT),
-    Int    ('i', "int",     PRIMITIVE | STACK_INT),
-    Float  ('f', "float",   PRIMITIVE),
-    Long   ('j', "long",    PRIMITIVE),
-    Double ('d', "double",  PRIMITIVE),
-    Object ('a', "Object",  0),
-    Void   ('v', "void",    0),
+    /** The primitive boolean kind, represented as an int on the stack. */
+    Boolean('z', "boolean", true, true),
+
+    /** The primitive byte kind, represented as an int on the stack. */
+    Byte('b', "byte", true, true),
+
+    /** The primitive short kind, represented as an int on the stack. */
+    Short('s', "short", true, true),
+
+    /** The primitive char kind, represented as an int on the stack. */
+    Char('c', "char", true, true),
+
+    /** The primitive int kind, represented as an int on the stack. */
+    Int('i', "int", true, true),
+
+    /** The primitive float kind. */
+    Float('f', "float", true, false),
+
+    /** The primitive long kind. */
+    Long('j', "long", true, false),
+
+    /** The primitive double kind. */
+    Double('d', "double", true, false),
+
+    /** The Object kind, also used for arrays. */
+    Object('a', "Object", false, false),
+
+    /** The void float kind. */
+    Void('v', "void", false, false),
+
     /** Denote a bytecode address in a {@code JSR} bytecode. */
-    Jsr    ('r', "jsr",     0),
-    /** The non-type. */
-    Illegal('-', "illegal", 0);
+    Jsr('r', "jsr", false, false),
 
-    public static final Kind[] VALUES = values();
-    public static final Kind[] JAVA_VALUES = new Kind[] {Kind.Boolean, Kind.Byte, Kind.Short, Kind.Char, Kind.Int, Kind.Float, Kind.Long, Kind.Double, Kind.Object};
+    /** The non-type. */
+    Illegal('-', "illegal", false, false);
 
-    Kind(char ch, String name, int flags) {
+    private Kind(char ch, String name, boolean isPrimitive, boolean isStackInt) {
         this.typeChar = ch;
         this.javaName = name;
-        this.flags = flags;
+        this.isPrimitive = isPrimitive;
+        this.isStackInt = isStackInt;
     }
 
-    static class Flags {
-        /**
-         * Behaves as an integer when on Java evaluation stack.
-         */
-        public static final int STACK_INT   = 0x0004;
-        /**
-         * Represents a Java primitive type.
-         */
-        public static final int PRIMITIVE   = 0x0008;
-    }
-
-    /**
-     * The flags for this kind.
-     */
-    private final int flags;
+    private final boolean isStackInt;
+    private final boolean isPrimitive;
 
     /**
      * The name of the kind as a single character.
@@ -82,39 +84,48 @@
     public final char typeChar;
 
     /**
-     * The name of this kind which will also be it Java programming language name if
-     * it is {@linkplain #isPrimitive() primitive} or {@code void}.
+     * The name of this kind which will also be it Java programming language name if it is {@linkplain #isPrimitive()
+     * primitive} or {@code void}.
      */
     public final String javaName;
 
     /**
      * Checks whether this type is valid as an {@code int} on the Java operand stack.
+     *
      * @return {@code true} if this type is represented by an {@code int} on the operand stack
      */
-    public boolean isInt() {
-        return (flags & STACK_INT) != 0;
+    public boolean isStackInt() {
+        return this.isStackInt;
     }
 
     /**
      * 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} or {@link #Double}.
+     *
+     * @return {@code true} if this is {@link #Boolean}, {@link #Byte}, {@link #Char}, {@link #Short}, {@link #Int},
+     *         {@link #Long}, {@link #Float} or {@link #Double}.
      */
     public boolean isPrimitive() {
-        return (flags & PRIMITIVE) != 0;
+        return this.isPrimitive;
     }
 
     /**
      * Gets the kind that represents this kind when on the Java operand stack.
+     *
      * @return the kind used on the operand stack
      */
     public Kind stackKind() {
-        if (isInt()) {
+        if (isStackInt()) {
             return Int;
         }
         return this;
     }
 
+    /**
+     * Returns the kind corresponding to the Java type string.
+     *
+     * @param typeString the Java type string
+     * @return the kind
+     */
     public static Kind fromTypeString(String typeString) {
         assert typeString.length() > 0;
         final char first = typeString.charAt(0);
@@ -126,62 +137,97 @@
 
     /**
      * Gets the kind from the character describing a primitive or void.
+     *
      * @param ch the character
      * @return the kind
      */
     public static Kind fromPrimitiveOrVoidTypeChar(char ch) {
-        // Checkstyle: stop
         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;
+            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;
         }
-        // Checkstyle: resume
         throw new IllegalArgumentException("unknown primitive or void type character: " + ch);
     }
 
+    /**
+     * Returns the Java class representing this kind.
+     *
+     * @return the Java class
+     */
     public Class< ? > toJavaClass() {
-        // Checkstyle: stop
-        switch(this) {
-            case Void:      return java.lang.Void.TYPE;
-            case Long:      return java.lang.Long.TYPE;
-            case Int:       return java.lang.Integer.TYPE;
-            case Byte:      return java.lang.Byte.TYPE;
-            case Char:      return java.lang.Character.TYPE;
-            case Double:    return java.lang.Double.TYPE;
-            case Float:     return java.lang.Float.TYPE;
-            case Short:     return java.lang.Short.TYPE;
-            case Boolean:   return java.lang.Boolean.TYPE;
-            default:        return null;
+        switch (this) {
+            case Void:
+                return java.lang.Void.TYPE;
+            case Long:
+                return java.lang.Long.TYPE;
+            case Int:
+                return java.lang.Integer.TYPE;
+            case Byte:
+                return java.lang.Byte.TYPE;
+            case Char:
+                return java.lang.Character.TYPE;
+            case Double:
+                return java.lang.Double.TYPE;
+            case Float:
+                return java.lang.Float.TYPE;
+            case Short:
+                return java.lang.Short.TYPE;
+            case Boolean:
+                return java.lang.Boolean.TYPE;
+            default:
+                return null;
         }
-        // Checkstyle: resume
     }
 
+    /**
+     * Returns the Java class for instances of boxed values of this kind.
+     *
+     * @return the Java class
+     */
     public Class< ? > toBoxedJavaClass() {
-        // Checkstyle: stop
-        switch(this) {
-            case Void:      return null;
-            case Long:      return java.lang.Long.class;
-            case Int:       return java.lang.Integer.class;
-            case Byte:      return java.lang.Byte.class;
-            case Char:      return java.lang.Character.class;
-            case Double:    return java.lang.Double.class;
-            case Float:     return java.lang.Float.class;
-            case Short:     return java.lang.Short.class;
-            case Boolean:   return java.lang.Boolean.class;
-            default:        return null;
+        switch (this) {
+            case Void:
+                return java.lang.Void.class;
+            case Long:
+                return java.lang.Long.class;
+            case Int:
+                return java.lang.Integer.class;
+            case Byte:
+                return java.lang.Byte.class;
+            case Char:
+                return java.lang.Character.class;
+            case Double:
+                return java.lang.Double.class;
+            case Float:
+                return java.lang.Float.class;
+            case Short:
+                return java.lang.Short.class;
+            case Boolean:
+                return java.lang.Boolean.class;
+            default:
+                return null;
         }
-        // Checkstyle: resume
     }
 
     /**
      * Checks whether this value type is void.
+     *
      * @return {@code true} if this type is void
      */
     public final boolean isVoid() {
@@ -190,6 +236,7 @@
 
     /**
      * Checks whether this value type is long.
+     *
      * @return {@code true} if this type is long
      */
     public final boolean isLong() {
@@ -198,6 +245,7 @@
 
     /**
      * Checks whether this value type is float.
+     *
      * @return {@code true} if this type is float
      */
     public final boolean isFloat() {
@@ -206,6 +254,7 @@
 
     /**
      * Checks whether this value type is double.
+     *
      * @return {@code true} if this type is double
      */
     public final boolean isDouble() {
@@ -214,14 +263,16 @@
 
     /**
      * Checks whether this value type is float or double.
+     *
      * @return {@code true} if this type is float or double
      */
     public final boolean isFloatOrDouble() {
         return this == Kind.Double || this == Kind.Float;
     }
 
-   /**
+    /**
      * Checks whether this value type is an object type.
+     *
      * @return {@code true} if this type is an object
      */
     public final boolean isObject() {
@@ -230,6 +281,7 @@
 
     /**
      * Checks whether this value type is an address type.
+     *
      * @return {@code true} if this type is an address
      */
     public boolean isJsr() {
@@ -245,10 +297,11 @@
     }
 
     /**
-     * Marker interface for types that should be {@linkplain Kind#format(Object) formatted}
-     * with their {@link Object#toString()} value.
+     * Marker interface for types that should be {@linkplain Kind#format(Object) formatted} with their
+     * {@link Object#toString()} value.
      */
-    public interface FormatWithToString {}
+    public interface FormatWithToString {
+    }
 
     /**
      * Gets a formatted string for a given value of this kind.
@@ -285,16 +338,13 @@
         }
     }
 
-    private static final int MAX_FORMAT_ARRAY_LENGTH = Integer.getInteger("maxFormatArrayLength", 5);
+    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("]{");
+        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++) {
@@ -314,12 +364,13 @@
         return buf.append('}').toString();
     }
 
-    public final char signatureChar() {
-        return Character.toUpperCase(typeChar);
-    }
-
-    public final int arrayBaseOffset() {
-        switch(this) {
+    /**
+     * The offset from the origin of an array to the first element.
+     *
+     * @return the offset in bytes
+     */
+    public final int getArrayBaseOffset() {
+        switch (this) {
             case Boolean:
                 return Unsafe.ARRAY_BOOLEAN_BASE_OFFSET;
             case Byte:
@@ -344,8 +395,13 @@
         }
     }
 
-    public final int arrayIndexScale() {
-        switch(this) {
+    /**
+     * The scale used for the index when accessing elements of an array of this kind.
+     *
+     * @return the scale in order to convert the index into a byte offset
+     */
+    public final int getArrayIndexScale() {
+        switch (this) {
             case Boolean:
                 return Unsafe.ARRAY_BOOLEAN_INDEX_SCALE;
             case Byte:
@@ -370,35 +426,47 @@
         }
     }
 
-    public Constant readUnsafeConstant(Object value, long displacement) {
-        assert value != null;
+    /**
+     * Utility function for reading a value of this kind using an object and a displacement.
+     *
+     * @param object the object from which the value is read
+     * @param displacement the displacement within the object in bytes
+     * @return the read value encapsulated in a {@link Constant} object
+     */
+    public Constant readUnsafeConstant(Object object, long displacement) {
+        assert object != null;
         Unsafe u = Unsafe.getUnsafe();
-        switch(this) {
+        switch (this) {
             case Boolean:
-                return Constant.forBoolean(u.getBoolean(value, displacement));
+                return Constant.forBoolean(u.getBoolean(object, displacement));
             case Byte:
-                return Constant.forByte(u.getByte(value, displacement));
+                return Constant.forByte(u.getByte(object, displacement));
             case Char:
-                return Constant.forChar(u.getChar(value, displacement));
+                return Constant.forChar(u.getChar(object, displacement));
             case Short:
-                return Constant.forShort(u.getShort(value, displacement));
+                return Constant.forShort(u.getShort(object, displacement));
             case Int:
-                return Constant.forInt(u.getInt(value, displacement));
+                return Constant.forInt(u.getInt(object, displacement));
             case Long:
-                return Constant.forLong(u.getLong(value, displacement));
+                return Constant.forLong(u.getLong(object, displacement));
             case Float:
-                return Constant.forFloat(u.getFloat(value, displacement));
+                return Constant.forFloat(u.getFloat(object, displacement));
             case Double:
-                return Constant.forDouble(u.getDouble(value, displacement));
+                return Constant.forDouble(u.getDouble(object, displacement));
             case Object:
-                return Constant.forObject(u.getObject(value, displacement));
+                return Constant.forObject(u.getObject(object, displacement));
             default:
                 assert false : "unexpected kind: " + this;
                 return null;
         }
     }
 
-    public long minValue() {
+    /**
+     * The minimum value that can be represented as a value of this kind.
+     *
+     * @return the minimum value
+     */
+    public long getMinValue() {
         switch (this) {
             case Boolean:
                 return 0;
@@ -418,7 +486,12 @@
         }
     }
 
-    public long maxValue() {
+    /**
+     * The maximum value that can be represented as a value of this kind.
+     *
+     * @return the maximum value
+     */
+    public long getMaxValue() {
         switch (this) {
             case Boolean:
                 return 1;
@@ -438,7 +511,12 @@
         }
     }
 
-    public int bits() {
+    /**
+     * 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;