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