rev 52786 : 8210031: implementation for JVM Constants API

   1 /*
   2  * Copyright (c) 2014, 2017, 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 package java.lang.invoke;
  27 



  28 import static java.lang.invoke.MethodHandleStatics.UNSAFE;
  29 
  30 final class VarHandles {
  31 
  32     static VarHandle makeFieldHandle(MemberName f, Class<?> refc, Class<?> type, boolean isWriteAllowedOnFinalFields) {
  33         if (!f.isStatic()) {
  34             long foffset = MethodHandleNatives.objectFieldOffset(f);
  35             if (!type.isPrimitive()) {
  36                 return f.isFinal() && !isWriteAllowedOnFinalFields
  37                        ? new VarHandleReferences.FieldInstanceReadOnly(refc, foffset, type)
  38                        : new VarHandleReferences.FieldInstanceReadWrite(refc, foffset, type);
  39             }
  40             else if (type == boolean.class) {
  41                 return f.isFinal() && !isWriteAllowedOnFinalFields
  42                        ? new VarHandleBooleans.FieldInstanceReadOnly(refc, foffset)
  43                        : new VarHandleBooleans.FieldInstanceReadWrite(refc, foffset);
  44             }
  45             else if (type == byte.class) {
  46                 return f.isFinal() && !isWriteAllowedOnFinalFields
  47                        ? new VarHandleBytes.FieldInstanceReadOnly(refc, foffset)
  48                        : new VarHandleBytes.FieldInstanceReadWrite(refc, foffset);
  49             }
  50             else if (type == short.class) {
  51                 return f.isFinal() && !isWriteAllowedOnFinalFields
  52                        ? new VarHandleShorts.FieldInstanceReadOnly(refc, foffset)
  53                        : new VarHandleShorts.FieldInstanceReadWrite(refc, foffset);
  54             }
  55             else if (type == char.class) {
  56                 return f.isFinal() && !isWriteAllowedOnFinalFields
  57                        ? new VarHandleChars.FieldInstanceReadOnly(refc, foffset)
  58                        : new VarHandleChars.FieldInstanceReadWrite(refc, foffset);
  59             }
  60             else if (type == int.class) {
  61                 return f.isFinal() && !isWriteAllowedOnFinalFields
  62                        ? new VarHandleInts.FieldInstanceReadOnly(refc, foffset)
  63                        : new VarHandleInts.FieldInstanceReadWrite(refc, foffset);
  64             }
  65             else if (type == long.class) {
  66                 return f.isFinal() && !isWriteAllowedOnFinalFields
  67                        ? new VarHandleLongs.FieldInstanceReadOnly(refc, foffset)
  68                        : new VarHandleLongs.FieldInstanceReadWrite(refc, foffset);
  69             }
  70             else if (type == float.class) {
  71                 return f.isFinal() && !isWriteAllowedOnFinalFields
  72                        ? new VarHandleFloats.FieldInstanceReadOnly(refc, foffset)
  73                        : new VarHandleFloats.FieldInstanceReadWrite(refc, foffset);
  74             }
  75             else if (type == double.class) {
  76                 return f.isFinal() && !isWriteAllowedOnFinalFields
  77                        ? new VarHandleDoubles.FieldInstanceReadOnly(refc, foffset)
  78                        : new VarHandleDoubles.FieldInstanceReadWrite(refc, foffset);
  79             }
  80             else {
  81                 throw new UnsupportedOperationException();
  82             }
  83         }
  84         else {
  85             // TODO This is not lazy on first invocation
  86             // and might cause some circular initialization issues
  87 
  88             // Replace with something similar to direct method handles
  89             // where a barrier is used then elided after use
  90 
  91             if (UNSAFE.shouldBeInitialized(refc))
  92                 UNSAFE.ensureClassInitialized(refc);
  93 
  94             Object base = MethodHandleNatives.staticFieldBase(f);
  95             long foffset = MethodHandleNatives.staticFieldOffset(f);
  96             if (!type.isPrimitive()) {
  97                 return f.isFinal() && !isWriteAllowedOnFinalFields
  98                        ? new VarHandleReferences.FieldStaticReadOnly(base, foffset, type)
  99                        : new VarHandleReferences.FieldStaticReadWrite(base, foffset, type);
 100             }
 101             else if (type == boolean.class) {
 102                 return f.isFinal() && !isWriteAllowedOnFinalFields
 103                        ? new VarHandleBooleans.FieldStaticReadOnly(base, foffset)
 104                        : new VarHandleBooleans.FieldStaticReadWrite(base, foffset);
 105             }
 106             else if (type == byte.class) {
 107                 return f.isFinal() && !isWriteAllowedOnFinalFields
 108                        ? new VarHandleBytes.FieldStaticReadOnly(base, foffset)
 109                        : new VarHandleBytes.FieldStaticReadWrite(base, foffset);
 110             }
 111             else if (type == short.class) {
 112                 return f.isFinal() && !isWriteAllowedOnFinalFields
 113                        ? new VarHandleShorts.FieldStaticReadOnly(base, foffset)
 114                        : new VarHandleShorts.FieldStaticReadWrite(base, foffset);
 115             }
 116             else if (type == char.class) {
 117                 return f.isFinal() && !isWriteAllowedOnFinalFields
 118                        ? new VarHandleChars.FieldStaticReadOnly(base, foffset)
 119                        : new VarHandleChars.FieldStaticReadWrite(base, foffset);
 120             }
 121             else if (type == int.class) {
 122                 return f.isFinal() && !isWriteAllowedOnFinalFields
 123                        ? new VarHandleInts.FieldStaticReadOnly(base, foffset)
 124                        : new VarHandleInts.FieldStaticReadWrite(base, foffset);
 125             }
 126             else if (type == long.class) {
 127                 return f.isFinal() && !isWriteAllowedOnFinalFields
 128                        ? new VarHandleLongs.FieldStaticReadOnly(base, foffset)
 129                        : new VarHandleLongs.FieldStaticReadWrite(base, foffset);
 130             }
 131             else if (type == float.class) {
 132                 return f.isFinal() && !isWriteAllowedOnFinalFields
 133                        ? new VarHandleFloats.FieldStaticReadOnly(base, foffset)
 134                        : new VarHandleFloats.FieldStaticReadWrite(base, foffset);
 135             }
 136             else if (type == double.class) {
 137                 return f.isFinal() && !isWriteAllowedOnFinalFields
 138                        ? new VarHandleDoubles.FieldStaticReadOnly(base, foffset)
 139                        : new VarHandleDoubles.FieldStaticReadWrite(base, foffset);
 140             }
 141             else {
 142                 throw new UnsupportedOperationException();
 143             }
 144         }
































 145     }
 146 
 147     static VarHandle makeArrayElementHandle(Class<?> arrayClass) {
 148         if (!arrayClass.isArray())
 149             throw new IllegalArgumentException("not an array: " + arrayClass);
 150 
 151         Class<?> componentType = arrayClass.getComponentType();
 152 
 153         int aoffset = UNSAFE.arrayBaseOffset(arrayClass);
 154         int ascale = UNSAFE.arrayIndexScale(arrayClass);
 155         int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
 156 
 157         if (!componentType.isPrimitive()) {
 158             return new VarHandleReferences.Array(aoffset, ashift, arrayClass);
 159         }
 160         else if (componentType == boolean.class) {
 161             return new VarHandleBooleans.Array(aoffset, ashift);
 162         }
 163         else if (componentType == byte.class) {
 164             return new VarHandleBytes.Array(aoffset, ashift);
 165         }
 166         else if (componentType == short.class) {
 167             return new VarHandleShorts.Array(aoffset, ashift);
 168         }
 169         else if (componentType == char.class) {
 170             return new VarHandleChars.Array(aoffset, ashift);
 171         }
 172         else if (componentType == int.class) {
 173             return new VarHandleInts.Array(aoffset, ashift);
 174         }
 175         else if (componentType == long.class) {
 176             return new VarHandleLongs.Array(aoffset, ashift);
 177         }
 178         else if (componentType == float.class) {
 179             return new VarHandleFloats.Array(aoffset, ashift);
 180         }
 181         else if (componentType == double.class) {
 182             return new VarHandleDoubles.Array(aoffset, ashift);
 183         }
 184         else {
 185             throw new UnsupportedOperationException();
 186         }
 187     }
 188 
 189     static VarHandle byteArrayViewHandle(Class<?> viewArrayClass,
 190                                          boolean be) {
 191         if (!viewArrayClass.isArray())
 192             throw new IllegalArgumentException("not an array: " + viewArrayClass);
 193 
 194         Class<?> viewComponentType = viewArrayClass.getComponentType();
 195 
 196         if (viewComponentType == long.class) {
 197             return new VarHandleByteArrayAsLongs.ArrayHandle(be);
 198         }
 199         else if (viewComponentType == int.class) {
 200             return new VarHandleByteArrayAsInts.ArrayHandle(be);
 201         }
 202         else if (viewComponentType == short.class) {
 203             return new VarHandleByteArrayAsShorts.ArrayHandle(be);
 204         }
 205         else if (viewComponentType == char.class) {
 206             return new VarHandleByteArrayAsChars.ArrayHandle(be);
 207         }
 208         else if (viewComponentType == double.class) {
 209             return new VarHandleByteArrayAsDoubles.ArrayHandle(be);
 210         }
 211         else if (viewComponentType == float.class) {
 212             return new VarHandleByteArrayAsFloats.ArrayHandle(be);
 213         }
 214 
 215         throw new UnsupportedOperationException();
 216     }
 217 
 218     static VarHandle makeByteBufferViewHandle(Class<?> viewArrayClass,
 219                                               boolean be) {
 220         if (!viewArrayClass.isArray())
 221             throw new IllegalArgumentException("not an array: " + viewArrayClass);
 222 
 223         Class<?> viewComponentType = viewArrayClass.getComponentType();
 224 
 225         if (viewComponentType == long.class) {
 226             return new VarHandleByteArrayAsLongs.ByteBufferHandle(be);
 227         }
 228         else if (viewComponentType == int.class) {
 229             return new VarHandleByteArrayAsInts.ByteBufferHandle(be);
 230         }
 231         else if (viewComponentType == short.class) {
 232             return new VarHandleByteArrayAsShorts.ByteBufferHandle(be);
 233         }
 234         else if (viewComponentType == char.class) {
 235             return new VarHandleByteArrayAsChars.ByteBufferHandle(be);
 236         }
 237         else if (viewComponentType == double.class) {
 238             return new VarHandleByteArrayAsDoubles.ByteBufferHandle(be);
 239         }
 240         else if (viewComponentType == float.class) {
 241             return new VarHandleByteArrayAsFloats.ByteBufferHandle(be);
 242         }
 243 
 244         throw new UnsupportedOperationException();
 245     }
 246 
 247 //    /**
 248 //     * A helper program to generate the VarHandleGuards class with a set of
 249 //     * static guard methods each of which corresponds to a particular shape and
 250 //     * performs a type check of the symbolic type descriptor with the VarHandle
 251 //     * type descriptor before linking/invoking to the underlying operation as
 252 //     * characterized by the operation member name on the VarForm of the
 253 //     * VarHandle.
 254 //     * <p>
 255 //     * The generated class essentially encapsulates pre-compiled LambdaForms,
 256 //     * one for each method, for the most set of common method signatures.
 257 //     * This reduces static initialization costs, footprint costs, and circular
 258 //     * dependencies that may arise if a class is generated per LambdaForm.
 259 //     * <p>
 260 //     * A maximum of L*T*S methods will be generated where L is the number of
 261 //     * access modes kinds (or unique operation signatures) and T is the number
 262 //     * of variable types and S is the number of shapes (such as instance field,
 263 //     * static field, or array access).
 264 //     * If there are 4 unique operation signatures, 5 basic types (Object, int,
 265 //     * long, float, double), and 3 shapes then a maximum of 60 methods will be
 266 //     * generated.  However, the number is likely to be less since there
 267 //     * be duplicate signatures.
 268 //     * <p>
 269 //     * Each method is annotated with @LambdaForm.Compiled to inform the runtime
 270 //     * that such methods should be treated as if a method of a class that is the
 271 //     * result of compiling a LambdaForm.  Annotation of such methods is
 272 //     * important for correct evaluation of certain assertions and method return
 273 //     * type profiling in HotSpot.
 274 //     */
 275 //    public static class GuardMethodGenerator {
 276 //
 277 //        static final String GUARD_METHOD_SIG_TEMPLATE = "<RETURN> <NAME>_<SIGNATURE>(<PARAMS>)";
 278 //
 279 //        static final String GUARD_METHOD_TEMPLATE =
 280 //                "@ForceInline\n" +
 281 //                "@LambdaForm.Compiled\n" +
 282 //                "final static <METHOD> throws Throwable {\n" +
 283 //                "    if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
 284 //                "        <RESULT_ERASED>MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);<RETURN_ERASED>\n" +
 285 //                "    }\n" +
 286 //                "    else {\n" +
 287 //                "        MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
 288 //                "        <RETURN>mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
 289 //                "    }\n" +
 290 //                "}";
 291 //
 292 //        static final String GUARD_METHOD_TEMPLATE_V =
 293 //                "@ForceInline\n" +
 294 //                "@LambdaForm.Compiled\n" +
 295 //                "final static <METHOD> throws Throwable {\n" +
 296 //                "    if (handle.vform.methodType_table[ad.type] == ad.symbolicMethodType) {\n" +
 297 //                "        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
 298 //                "    }\n" +
 299 //                "    else if (handle.vform.getMethodType_V(ad.type) == ad.symbolicMethodType) {\n" +
 300 //                "        MethodHandle.linkToStatic(<LINK_TO_STATIC_ARGS>);\n" +
 301 //                "    }\n" +
 302 //                "    else {\n" +
 303 //                "        MethodHandle mh = handle.getMethodHandle(ad.mode);\n" +
 304 //                "        mh.asType(ad.symbolicMethodTypeInvoker).invokeBasic(<LINK_TO_INVOKER_ARGS>);\n" +
 305 //                "    }\n" +
 306 //                "}";
 307 //
 308 //        // A template for deriving the operations
 309 //        // could be supported by annotating VarHandle directly with the
 310 //        // operation kind and shape
 311 //        interface VarHandleTemplate {
 312 //            Object get();
 313 //
 314 //            void set(Object value);
 315 //
 316 //            boolean compareAndSet(Object actualValue, Object expectedValue);
 317 //
 318 //            Object compareAndExchange(Object actualValue, Object expectedValue);
 319 //
 320 //            Object getAndUpdate(Object value);
 321 //        }
 322 //
 323 //        static class HandleType {
 324 //            final Class<?> receiver;
 325 //            final Class<?>[] intermediates;
 326 //            final Class<?> value;
 327 //
 328 //            HandleType(Class<?> receiver, Class<?> value, Class<?>... intermediates) {
 329 //                this.receiver = receiver;
 330 //                this.intermediates = intermediates;
 331 //                this.value = value;
 332 //            }
 333 //        }
 334 //
 335 //        /**
 336 //         * @param args parameters
 337 //         */
 338 //        public static void main(String[] args) {
 339 //            System.out.println("package java.lang.invoke;");
 340 //            System.out.println();
 341 //            System.out.println("import jdk.internal.vm.annotation.ForceInline;");
 342 //            System.out.println();
 343 //            System.out.println("// This class is auto-generated by " +
 344 //                               GuardMethodGenerator.class.getName() +
 345 //                               ". Do not edit.");
 346 //            System.out.println("final class VarHandleGuards {");
 347 //
 348 //            System.out.println();
 349 //
 350 //            // Declare the stream of shapes
 351 //            Stream<HandleType> hts = Stream.of(
 352 //                    // Object->Object
 353 //                    new HandleType(Object.class, Object.class),
 354 //                    // Object->int
 355 //                    new HandleType(Object.class, int.class),
 356 //                    // Object->long
 357 //                    new HandleType(Object.class, long.class),
 358 //                    // Object->float
 359 //                    new HandleType(Object.class, float.class),
 360 //                    // Object->double
 361 //                    new HandleType(Object.class, double.class),
 362 //
 363 //                    // <static>->Object
 364 //                    new HandleType(null, Object.class),
 365 //                    // <static>->int
 366 //                    new HandleType(null, int.class),
 367 //                    // <static>->long
 368 //                    new HandleType(null, long.class),
 369 //                    // <static>->float
 370 //                    new HandleType(null, float.class),
 371 //                    // <static>->double
 372 //                    new HandleType(null, double.class),
 373 //
 374 //                    // Array[int]->Object
 375 //                    new HandleType(Object.class, Object.class, int.class),
 376 //                    // Array[int]->int
 377 //                    new HandleType(Object.class, int.class, int.class),
 378 //                    // Array[int]->long
 379 //                    new HandleType(Object.class, long.class, int.class),
 380 //                    // Array[int]->float
 381 //                    new HandleType(Object.class, float.class, int.class),
 382 //                    // Array[int]->double
 383 //                    new HandleType(Object.class, double.class, int.class),
 384 //
 385 //                    // Array[long]->int
 386 //                    new HandleType(Object.class, int.class, long.class),
 387 //                    // Array[long]->long
 388 //                    new HandleType(Object.class, long.class, long.class)
 389 //            );
 390 //
 391 //            hts.flatMap(ht -> Stream.of(VarHandleTemplate.class.getMethods()).
 392 //                    map(m -> generateMethodType(m, ht.receiver, ht.value, ht.intermediates))).
 393 //                    distinct().
 394 //                    map(mt -> generateMethod(mt)).
 395 //                    forEach(s -> {
 396 //                        System.out.println(s);
 397 //                        System.out.println();
 398 //                    });
 399 //
 400 //            System.out.println("}");
 401 //        }
 402 //
 403 //        static MethodType generateMethodType(Method m, Class<?> receiver, Class<?> value, Class<?>... intermediates) {
 404 //            Class<?> returnType = m.getReturnType() == Object.class
 405 //                                  ? value : m.getReturnType();
 406 //
 407 //            List<Class<?>> params = new ArrayList<>();
 408 //            if (receiver != null)
 409 //                params.add(receiver);
 410 //            for (int i = 0; i < intermediates.length; i++) {
 411 //                params.add(intermediates[i]);
 412 //            }
 413 //            for (Parameter p : m.getParameters()) {
 414 //                params.add(value);
 415 //            }
 416 //            return MethodType.methodType(returnType, params);
 417 //        }
 418 //
 419 //        static String generateMethod(MethodType mt) {
 420 //            Class<?> returnType = mt.returnType();
 421 //
 422 //            LinkedHashMap<String, Class<?>> params = new LinkedHashMap<>();
 423 //            params.put("handle", VarHandle.class);
 424 //            for (int i = 0; i < mt.parameterCount(); i++) {
 425 //                params.put("arg" + i, mt.parameterType(i));
 426 //            }
 427 //            params.put("ad", VarHandle.AccessDescriptor.class);
 428 //
 429 //            // Generate method signature line
 430 //            String RETURN = className(returnType);
 431 //            String NAME = "guard";
 432 //            String SIGNATURE = getSignature(mt);
 433 //            String PARAMS = params.entrySet().stream().
 434 //                    map(e -> className(e.getValue()) + " " + e.getKey()).
 435 //                    collect(joining(", "));
 436 //            String METHOD = GUARD_METHOD_SIG_TEMPLATE.
 437 //                    replace("<RETURN>", RETURN).
 438 //                    replace("<NAME>", NAME).
 439 //                    replace("<SIGNATURE>", SIGNATURE).
 440 //                    replace("<PARAMS>", PARAMS);
 441 //
 442 //            // Generate method
 443 //            params.remove("ad");
 444 //
 445 //            List<String> LINK_TO_STATIC_ARGS = params.keySet().stream().
 446 //                    collect(toList());
 447 //            LINK_TO_STATIC_ARGS.add("handle.vform.getMemberName(ad.mode)");
 448 //            List<String> LINK_TO_STATIC_ARGS_V = params.keySet().stream().
 449 //                    collect(toList());
 450 //            LINK_TO_STATIC_ARGS_V.add("handle.vform.getMemberName_V(ad.mode)");
 451 //
 452 //            List<String> LINK_TO_INVOKER_ARGS = params.keySet().stream().
 453 //                    collect(toList());
 454 //
 455 //            RETURN = returnType == void.class
 456 //                     ? ""
 457 //                     : returnType == Object.class
 458 //                       ? "return "
 459 //                       : "return (" + returnType.getName() + ") ";
 460 //
 461 //            String RESULT_ERASED = returnType == void.class
 462 //                                   ? ""
 463 //                                   : returnType != Object.class
 464 //                                     ? "return (" + returnType.getName() + ") "
 465 //                                     : "Object r = ";
 466 //
 467 //            String RETURN_ERASED = returnType != Object.class
 468 //                                   ? ""
 469 //                                   : " return ad.returnType.cast(r);";
 470 //
 471 //            String template = returnType == void.class
 472 //                              ? GUARD_METHOD_TEMPLATE_V
 473 //                              : GUARD_METHOD_TEMPLATE;
 474 //            return template.
 475 //                    replace("<METHOD>", METHOD).
 476 //                    replace("<NAME>", NAME).
 477 //                    replaceAll("<RETURN>", RETURN).
 478 //                    replace("<RESULT_ERASED>", RESULT_ERASED).
 479 //                    replace("<RETURN_ERASED>", RETURN_ERASED).
 480 //                    replaceAll("<LINK_TO_STATIC_ARGS>", LINK_TO_STATIC_ARGS.stream().
 481 //                            collect(joining(", "))).
 482 //                    replaceAll("<LINK_TO_STATIC_ARGS_V>", LINK_TO_STATIC_ARGS_V.stream().
 483 //                            collect(joining(", "))).
 484 //                    replace("<LINK_TO_INVOKER_ARGS>", LINK_TO_INVOKER_ARGS.stream().
 485 //                            collect(joining(", ")))
 486 //                    ;
 487 //        }
 488 //
 489 //        static String className(Class<?> c) {
 490 //            String n = c.getName();
 491 //            if (n.startsWith("java.lang.")) {
 492 //                n = n.replace("java.lang.", "");
 493 //                if (n.startsWith("invoke.")) {
 494 //                    n = n.replace("invoke.", "");
 495 //                }
 496 //            }
 497 //            return n.replace('$', '.');
 498 //        }
 499 //
 500 //        static String getSignature(MethodType m) {
 501 //            StringBuilder sb = new StringBuilder(m.parameterCount() + 1);
 502 //
 503 //            for (int i = 0; i < m.parameterCount(); i++) {
 504 //                Class<?> pt = m.parameterType(i);
 505 //                sb.append(getCharType(pt));
 506 //            }
 507 //
 508 //            sb.append('_').append(getCharType(m.returnType()));
 509 //
 510 //            return sb.toString();
 511 //        }
 512 //
 513 //        static char getCharType(Class<?> pt) {
 514 //            if (pt == void.class) {
 515 //                return 'V';
 516 //            }
 517 //            else if (!pt.isPrimitive()) {
 518 //                return 'L';
 519 //            }
 520 //            else if (pt == boolean.class) {
 521 //                return 'Z';
 522 //            }
 523 //            else if (pt == int.class) {
 524 //                return 'I';
 525 //            }
 526 //            else if (pt == long.class) {
 527 //                return 'J';
 528 //            }
 529 //            else if (pt == float.class) {
 530 //                return 'F';
 531 //            }
 532 //            else if (pt == double.class) {
 533 //                return 'D';
 534 //            }
 535 //            else {
 536 //                throw new IllegalStateException(pt.getName());
 537 //            }
 538 //        }
 539 //    }
 540 }
--- EOF ---