1 /*
   2  * Copyright (c) 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * @test
  28  * @summary tests on constant folding of unsafe get operations
  29  * @library /testlibrary /../../test/lib
  30  * @run main/bootclasspath -XX:+UnlockDiagnosticVMOptions
  31  *                   -Xbatch -XX:-TieredCompilation -Xverify:all
  32  *                   -XX:+FoldStableValues
  33  *                   -XX:+UseUnalignedAccesses
  34  *                   java.lang.invoke.UnsafeGetConstantField
  35  * @run main/bootclasspath -XX:+UnlockDiagnosticVMOptions
  36  *                   -Xbatch -XX:-TieredCompilation -Xverify:all
  37  *                   -XX:+FoldStableValues
  38  *                   -XX:-UseUnalignedAccesses
  39  *                   java.lang.invoke.UnsafeGetConstantField
  40  */
  41 package java.lang.invoke;
  42 
  43 import jdk.internal.org.objectweb.asm.*;
  44 import jdk.test.lib.Asserts;
  45 import jdk.test.lib.Utils;
  46 import sun.misc.Unsafe;
  47 import static jdk.internal.org.objectweb.asm.Opcodes.*;
  48 
  49 public class UnsafeGetConstantField {
  50     static final Class<?> THIS_CLASS = UnsafeGetConstantField.class;
  51 
  52     static final Unsafe U = Utils.getUnsafe();
  53 
  54     public static void main(String[] args) {
  55         testUnsafeGetAddress();
  56         testUnsafeGetField();
  57         testUnsafeGetFieldUnaligned();
  58         System.out.println("TEST PASSED");
  59     }
  60 
  61     static final long nativeAddr = U.allocateMemory(16);
  62     static void testUnsafeGetAddress() {
  63         long cookie = 0x12345678L;
  64         U.putAddress(nativeAddr, cookie);
  65         for (int i = 0; i < 20_000; i++) {
  66             Asserts.assertEquals(checkGetAddress(), cookie);
  67         }
  68     }
  69     @DontInline
  70     static long checkGetAddress() {
  71         return U.getAddress(nativeAddr);
  72     }
  73 
  74     static void testUnsafeGetField() {
  75         int[] testedFlags = new int[] { 0, ACC_STATIC, ACC_FINAL, (ACC_STATIC | ACC_FINAL) };
  76         boolean[] boolValues = new boolean[] { false, true };
  77         String[] modes = new String[] { "", "Volatile" };
  78 
  79         for (JavaType t : JavaType.values()) {
  80             for (int flags : testedFlags) {
  81                 for (boolean stable : boolValues) {
  82                     for (boolean hasDefaultValue : boolValues) {
  83                         for (String suffix : modes) {
  84                             runTest(t, flags, stable, hasDefaultValue, suffix);
  85                         }
  86                     }
  87                 }
  88             }
  89         }
  90     }
  91 
  92     static void testUnsafeGetFieldUnaligned() {
  93         JavaType[] types = new JavaType[] { JavaType.S, JavaType.C, JavaType.I, JavaType.J };
  94         int[] testedFlags = new int[] { 0, ACC_STATIC, ACC_FINAL, (ACC_STATIC | ACC_FINAL) };
  95         boolean[] boolValues = new boolean[] { false, true };
  96 
  97         for (JavaType t : types) {
  98             for (int flags : testedFlags) {
  99                 for (boolean stable : boolValues) {
 100                     for (boolean hasDefaultValue : boolValues) {
 101                         runTest(t, flags, stable, hasDefaultValue, "Unaligned");
 102                     }
 103                 }
 104             }
 105         }
 106     }
 107 
 108     static void runTest(JavaType t, int flags, boolean stable, boolean hasDefaultValue, String postfix) {
 109         Generator g = new Generator(t, flags, stable, hasDefaultValue, postfix);
 110         Test test = g.generate();
 111         System.out.printf("type=%s flags=%d stable=%b default=%b post=%s\n",
 112                           t.typeName, flags, stable, hasDefaultValue, postfix);
 113         // Trigger compilation
 114         for (int i = 0; i < 20_000; i++) {
 115             Asserts.assertEQ(test.testDirect(), test.testUnsafe());
 116         }
 117     }
 118 
 119     interface Test {
 120         Object testDirect();
 121         Object testUnsafe();
 122     }
 123 
 124     enum JavaType {
 125         Z("Boolean", true),
 126         B("Byte", new Byte((byte)-1)),
 127         S("Short", new Short((short)-1)),
 128         C("Char", Character.MAX_VALUE),
 129         I("Int", -1),
 130         J("Long", -1L),
 131         F("Float", -1F),
 132         D("Double", -1D),
 133         L("Object", new Object());
 134 
 135         String typeName;
 136         Object value;
 137         String wrapper;
 138         JavaType(String name, Object value) {
 139             this.typeName = name;
 140             this.value = value;
 141             this.wrapper = internalName(value.getClass());
 142         }
 143 
 144         String desc() {
 145             if (this == JavaType.L) {
 146                 return "Ljava/lang/Object;";
 147             } else {
 148                 return toString();
 149             }
 150         }
 151     }
 152 
 153     static String internalName(Class cls) {
 154         return cls.getName().replace('.', '/');
 155     }
 156     static String descriptor(Class cls) {
 157         return String.format("L%s;", internalName(cls));
 158     }
 159 
 160     /**
 161      * Sample generated class:
 162      * static class T1 implements Test {
 163      *   final int f = -1;
 164      *   static final long FIELD_OFFSET;
 165      *   static final T1 t = new T1();
 166      *   static {
 167      *     FIELD_OFFSET = U.objectFieldOffset(T1.class.getDeclaredField("f"));
 168      *   }
 169      *   public Object testDirect()  { return t.f; }
 170      *   public Object testUnsafe()  { return U.getInt(t, FIELD_OFFSET); }
 171      * }
 172      */
 173     static class Generator {
 174         static final String FIELD_NAME = "f";
 175         static final String UNSAFE_NAME = internalName(Unsafe.class);
 176         static final String UNSAFE_DESC = descriptor(Unsafe.class);
 177 
 178         final JavaType type;
 179         final int flags;
 180         final boolean stable;
 181         final boolean hasDefaultValue;
 182         final String nameSuffix;
 183         final boolean useRawOffset;
 184 
 185         final String className;
 186         final String classDesc;
 187         final String fieldDesc;
 188 
 189         Generator(JavaType t, int flags, boolean stable, boolean hasDefaultValue, String suffix) {
 190             this.type = t;
 191             this.flags = flags;
 192             this.stable = stable;
 193             this.hasDefaultValue = hasDefaultValue;
 194             this.nameSuffix = suffix;
 195 
 196             useRawOffset = suffix.equals("Unaligned");
 197             fieldDesc = type.desc();
 198             className = String.format("%s$Test%s%s__f=%d__s=%b__d=%b", internalName(THIS_CLASS), type.typeName,
 199                                       suffix, flags, stable, hasDefaultValue);
 200             classDesc = String.format("L%s;", className);
 201         }
 202 
 203         byte[] generateClassFile() {
 204             ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
 205             cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, className, null, "java/lang/Object",
 206                     new String[]{ internalName(Test.class) });
 207 
 208             // Declare fields
 209             cw.visitField(ACC_FINAL | ACC_STATIC, "t", classDesc, null, null).visitEnd();
 210             cw.visitField(ACC_FINAL | ACC_STATIC, "FIELD_OFFSET", "J", null, null).visitEnd();
 211             cw.visitField(ACC_FINAL | ACC_STATIC, "U", UNSAFE_DESC, null, null).visitEnd();
 212             if (isStatic()) {
 213                 cw.visitField(ACC_FINAL | ACC_STATIC, "STATIC_BASE", "Ljava/lang/Object;", null, null).visitEnd();
 214             }
 215 
 216             FieldVisitor fv = cw.visitField(flags, FIELD_NAME, fieldDesc, null, null);
 217             if (stable) {
 218                 fv.visitAnnotation(descriptor(Stable.class), true);
 219             }
 220             fv.visitEnd();
 221 
 222             // Methods
 223             {   // <init>
 224                 MethodVisitor mv = cw.visitMethod(0, "<init>", "()V", null, null);
 225                 mv.visitCode();
 226 
 227                 mv.visitVarInsn(ALOAD, 0);
 228                 mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
 229                 if (!isStatic()) {
 230                     initField(mv);
 231                 }
 232                 mv.visitInsn(RETURN);
 233 
 234                 mv.visitMaxs(0, 0);
 235                 mv.visitEnd();
 236             }
 237 
 238             {   // public Object testDirect() { return t.f; }
 239                 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testDirect", "()Ljava/lang/Object;", null, null);
 240                 mv.visitCode();
 241 
 242                 getFieldValue(mv);
 243                 wrapResult(mv);
 244                 mv.visitInsn(ARETURN);
 245 
 246                 mv.visitMaxs(0, 0);
 247                 mv.visitEnd();
 248             }
 249 
 250             {   // public Object testUnsafe() { return U.getInt(t, FIELD_OFFSET); }
 251                 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testUnsafe", "()Ljava/lang/Object;", null, null);
 252                 mv.visitCode();
 253 
 254                 getFieldValueUnsafe(mv);
 255                 wrapResult(mv);
 256                 mv.visitInsn(ARETURN);
 257 
 258                 mv.visitMaxs(0, 0);
 259                 mv.visitEnd();
 260             }
 261 
 262             {   // <clinit>
 263                 MethodVisitor mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
 264                 mv.visitCode();
 265 
 266                 // Cache Unsafe instance
 267                 mv.visitMethodInsn(INVOKESTATIC, UNSAFE_NAME, "getUnsafe", "()"+UNSAFE_DESC, false);
 268                 mv.visitFieldInsn(PUTSTATIC, className, "U", UNSAFE_DESC);
 269 
 270                 // Create test object instance
 271                 mv.visitTypeInsn(NEW, className);
 272                 mv.visitInsn(DUP);
 273                 mv.visitMethodInsn(INVOKESPECIAL, className, "<init>", "()V", false);
 274                 mv.visitFieldInsn(PUTSTATIC, className, "t", classDesc);
 275 
 276                 // Compute field offset
 277                 getUnsafe(mv);
 278                 getField(mv);
 279                 mv.visitMethodInsn(INVOKEVIRTUAL, UNSAFE_NAME, (isStatic() ? "staticFieldOffset" : "objectFieldOffset"),
 280                         "(Ljava/lang/reflect/Field;)J", false);
 281                 if (useRawOffset) {
 282                     mv.visitLdcInsn(1);
 283                     mv.visitInsn(LSHR);
 284                 }
 285                 mv.visitFieldInsn(PUTSTATIC, className, "FIELD_OFFSET", "J");
 286 
 287                 // Compute base offset for static field
 288                 if (isStatic()) {
 289                     getUnsafe(mv);
 290                     getField(mv);
 291                     mv.visitMethodInsn(INVOKEVIRTUAL, UNSAFE_NAME, "staticFieldBase", "(Ljava/lang/reflect/Field;)Ljava/lang/Object;", false);
 292                     mv.visitFieldInsn(PUTSTATIC, className, "STATIC_BASE", "Ljava/lang/Object;");
 293                     initField(mv);
 294                 }
 295 
 296                 mv.visitInsn(RETURN);
 297                 mv.visitMaxs(0, 0);
 298                 mv.visitEnd();
 299             }
 300 
 301             return cw.toByteArray();
 302         }
 303 
 304         Test generate() {
 305             byte[] classFile = generateClassFile();
 306             Class<?> c = U.defineClass(className, classFile, 0, classFile.length, THIS_CLASS.getClassLoader(), null);
 307             try {
 308                 return (Test) c.newInstance();
 309             } catch(Exception e) {
 310                 throw new Error(e);
 311             }
 312         }
 313 
 314         boolean isStatic() {
 315             return (flags & ACC_STATIC) > 0;
 316         }
 317         boolean isFinal() {
 318             return (flags & ACC_FINAL) > 0;
 319         }
 320         void getUnsafe(MethodVisitor mv) {
 321             mv.visitFieldInsn(GETSTATIC, className, "U", UNSAFE_DESC);
 322         }
 323         void getField(MethodVisitor mv) {
 324             mv.visitLdcInsn(Type.getType(classDesc));
 325             mv.visitLdcInsn(FIELD_NAME);
 326             mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getDeclaredField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;", false);
 327         }
 328         void getFieldValue(MethodVisitor mv) {
 329             if (isStatic()) {
 330                 mv.visitFieldInsn(GETSTATIC, className, FIELD_NAME, fieldDesc);
 331             } else {
 332                 mv.visitFieldInsn(GETSTATIC, className, "t", classDesc);
 333                 mv.visitFieldInsn(GETFIELD, className, FIELD_NAME, fieldDesc);
 334             }
 335         }
 336         void getFieldValueUnsafe(MethodVisitor mv) {
 337             getUnsafe(mv);
 338             if (isStatic()) {
 339                 mv.visitFieldInsn(GETSTATIC, className, "STATIC_BASE", "Ljava/lang/Object;");
 340             } else {
 341                 mv.visitFieldInsn(GETSTATIC, className, "t", classDesc);
 342             }
 343             mv.visitFieldInsn(GETSTATIC, className, "FIELD_OFFSET", "J");
 344             String name = "get" + type.typeName + nameSuffix;
 345             mv.visitMethodInsn(INVOKEVIRTUAL, UNSAFE_NAME, name, "(Ljava/lang/Object;J)" + type.desc(), false);
 346         }
 347         void wrapResult(MethodVisitor mv) {
 348             if (type != JavaType.L) {
 349                 String desc = String.format("(%s)L%s;", type.desc(), type.wrapper);
 350                 mv.visitMethodInsn(INVOKESTATIC, type.wrapper, "valueOf", desc, false);
 351             }
 352         }
 353         void initField(MethodVisitor mv) {
 354             if (hasDefaultValue) {
 355                 return; // Nothing to do
 356             }
 357             if (!isStatic()) {
 358                 mv.visitVarInsn(ALOAD, 0);
 359             }
 360             switch (type) {
 361                 case L: {
 362                     mv.visitTypeInsn(NEW, "java/lang/Object");
 363                     mv.visitInsn(DUP);
 364                     mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
 365 
 366                     break;
 367                 }
 368                 default: {
 369                     mv.visitLdcInsn(type.value);
 370                     break;
 371                 }
 372             }
 373             mv.visitFieldInsn((isStatic() ? PUTSTATIC : PUTFIELD), className, FIELD_NAME, fieldDesc);
 374         }
 375     }
 376 }
--- EOF ---