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