1 /* 2 * Copyright (c) 2017, 2024, 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.runtime; 27 28 import java.lang.Enum.EnumDesc; 29 import java.lang.classfile.CodeBuilder; 30 import java.lang.constant.ClassDesc; 31 import java.lang.constant.ConstantDesc; 32 import java.lang.constant.ConstantDescs; 33 import java.lang.constant.MethodTypeDesc; 34 import java.lang.invoke.CallSite; 35 import java.lang.invoke.ConstantCallSite; 36 import java.lang.invoke.MethodHandle; 37 import java.lang.invoke.MethodHandles; 38 import java.lang.invoke.MethodType; 39 import java.lang.reflect.AccessFlag; 40 import java.util.ArrayList; 41 import java.util.List; 42 import java.util.Objects; 43 import java.util.Optional; 44 import java.util.function.BiPredicate; 45 import java.util.function.Consumer; 46 47 import jdk.internal.access.SharedSecrets; 48 import java.lang.classfile.ClassFile; 49 import java.lang.classfile.Label; 50 import java.lang.classfile.instruction.SwitchCase; 51 52 import jdk.internal.constant.ConstantUtils; 53 import jdk.internal.constant.MethodTypeDescImpl; 54 import jdk.internal.constant.ReferenceClassDescImpl; 55 import jdk.internal.misc.PreviewFeatures; 56 import jdk.internal.vm.annotation.Stable; 57 58 import static java.lang.invoke.MethodHandles.Lookup.ClassOption.NESTMATE; 59 import static java.lang.invoke.MethodHandles.Lookup.ClassOption.STRONG; 60 import java.util.Arrays; 61 import java.util.HashMap; 62 import java.util.Map; 63 import static java.util.Objects.requireNonNull; 64 import static jdk.internal.constant.ConstantUtils.classDesc; 65 import static jdk.internal.constant.ConstantUtils.referenceClassDesc; 66 67 import sun.invoke.util.Wrapper; 68 69 /** 70 * Bootstrap methods for linking {@code invokedynamic} call sites that implement 71 * the selection functionality of the {@code switch} statement. The bootstraps 72 * take additional static arguments corresponding to the {@code case} labels 73 * of the {@code switch}, implicitly numbered sequentially from {@code [0..N)}. 74 * 75 * @since 21 76 */ 77 public class SwitchBootstraps { 78 79 private SwitchBootstraps() {} 80 81 private static final Object SENTINEL = new Object(); 82 private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); 83 private static final boolean previewEnabled = PreviewFeatures.isEnabled(); 84 85 private static final ClassDesc CD_BiPredicate = ReferenceClassDescImpl.ofValidated("Ljava/util/function/BiPredicate;"); 86 private static final ClassDesc CD_Objects = ReferenceClassDescImpl.ofValidated("Ljava/util/Objects;"); 87 88 private static final MethodTypeDesc CHECK_INDEX_DESCRIPTOR = 89 MethodTypeDescImpl.ofValidated(ConstantDescs.CD_int, ConstantDescs.CD_int, ConstantDescs.CD_int); 90 private static final MethodTypeDesc MTD_TYPE_SWITCH = MethodTypeDescImpl.ofValidated(ConstantDescs.CD_int, 91 ConstantDescs.CD_Object, 92 ConstantDescs.CD_int); 93 private static final MethodTypeDesc MTD_TYPE_SWITCH_EXTRA = MethodTypeDescImpl.ofValidated(ConstantDescs.CD_int, 94 ConstantDescs.CD_Object, 95 ConstantDescs.CD_int, 96 CD_BiPredicate, 97 ConstantDescs.CD_List); 98 private static final MethodType MT_TYPE_SWITCH_EXTRA = MethodType.methodType(int.class, 99 Object.class, 100 int.class, 101 BiPredicate.class, 102 List.class); 103 private static final MethodType MT_TYPE_SWITCH = MethodType.methodType(int.class, 104 Object.class, 105 int.class); 106 107 private static class StaticHolders { 108 private static final MethodHandle MAPPED_ENUM_SWITCH; 109 110 static { 111 try { 112 MAPPED_ENUM_SWITCH = LOOKUP.findStatic(SwitchBootstraps.class, "mappedEnumSwitch", 113 MethodType.methodType(int.class, Enum.class, int.class, MethodHandles.Lookup.class, 114 Class.class, EnumDesc[].class, MappedEnumCache.class)); 115 } 116 catch (ReflectiveOperationException e) { 117 throw new ExceptionInInitializerError(e); 118 } 119 } 120 } 121 122 /** 123 * Bootstrap method for linking an {@code invokedynamic} call site that 124 * implements a {@code switch} on a target of a reference type. The static 125 * arguments are an array of case labels which must be non-null and of type 126 * {@code String} or {@code Integer} or {@code Class} or {@code EnumDesc}. 127 * <p> 128 * The type of the returned {@code CallSite}'s method handle will have 129 * a return type of {@code int}. It has two parameters: the first argument 130 * will be an {@code Object} instance ({@code target}) and the second 131 * will be {@code int} ({@code restart}). 132 * <p> 133 * If the {@code target} is {@code null}, then the method of the call site 134 * returns {@literal -1}. 135 * <p> 136 * If the {@code target} is not {@code null}, then the method of the call site 137 * returns the index of the first element in the {@code labels} array starting from 138 * the {@code restart} index matching one of the following conditions: 139 * <ul> 140 * <li>the element is of type {@code Class} that is assignable 141 * from the target's class; or</li> 142 * <li>the element is of type {@code String} or {@code Integer} and 143 * equals to the target.</li> 144 * <li>the element is of type {@code EnumDesc}, that describes a constant that is 145 * equals to the target.</li> 146 * </ul> 147 * <p> 148 * If no element in the {@code labels} array matches the target, then 149 * the method of the call site return the length of the {@code labels} array. 150 * <p> 151 * The value of the {@code restart} index must be between {@code 0} (inclusive) and 152 * the length of the {@code labels} array (inclusive), 153 * both or an {@link IndexOutOfBoundsException} is thrown. 154 * 155 * @param lookup Represents a lookup context with the accessibility 156 * privileges of the caller. When used with {@code invokedynamic}, 157 * this is stacked automatically by the VM. 158 * @param invocationName unused 159 * @param invocationType The invocation type of the {@code CallSite} with two parameters, 160 * a reference type, an {@code int}, and {@code int} as a return type. 161 * @param labels case labels - {@code String} and {@code Integer} constants 162 * and {@code Class} and {@code EnumDesc} instances, in any combination 163 * @return a {@code CallSite} returning the first matching element as described above 164 * 165 * @throws NullPointerException if any argument is {@code null} 166 * @throws IllegalArgumentException if any element in the labels array is null 167 * @throws IllegalArgumentException if the invocation type is not a method type of first parameter of a reference type, 168 * second parameter of type {@code int} and with {@code int} as its return type, 169 * @throws IllegalArgumentException if {@code labels} contains an element that is not of type {@code String}, 170 * {@code Integer}, {@code Long}, {@code Float}, {@code Double}, {@code Boolean}, 171 * {@code Class} or {@code EnumDesc}. 172 * @throws IllegalArgumentException if {@code labels} contains an element that is not of type {@code Boolean} 173 * when {@code target} is a {@code Boolean.class}. 174 * @jvms 4.4.6 The CONSTANT_NameAndType_info Structure 175 * @jvms 4.4.10 The CONSTANT_Dynamic_info and CONSTANT_InvokeDynamic_info Structures 176 */ 177 public static CallSite typeSwitch(MethodHandles.Lookup lookup, 178 String invocationName, 179 MethodType invocationType, 180 Object... labels) { 181 Class<?> selectorType = invocationType.parameterType(0); 182 if (invocationType.parameterCount() != 2 183 || (!invocationType.returnType().equals(int.class)) 184 || !invocationType.parameterType(1).equals(int.class)) 185 throw new IllegalArgumentException("Illegal invocation type " + invocationType); 186 187 for (Object l : labels) { // implicit null-check 188 verifyLabel(l, selectorType); 189 } 190 191 MethodHandle target = generateTypeSwitch(lookup, selectorType, labels); 192 target = target.asType(invocationType); 193 return new ConstantCallSite(target); 194 } 195 196 private static void verifyLabel(Object label, Class<?> selectorType) { 197 if (label == null) { 198 throw new IllegalArgumentException("null label found"); 199 } 200 Class<?> labelClass = label.getClass(); 201 202 if (labelClass != Class.class && 203 labelClass != String.class && 204 labelClass != Integer.class && 205 206 ((labelClass != Float.class && 207 labelClass != Long.class && 208 labelClass != Double.class && 209 labelClass != Boolean.class) || 210 ((selectorType.equals(boolean.class) || selectorType.equals(Boolean.class)) && labelClass != Boolean.class && labelClass != Class.class) || 211 !previewEnabled) && 212 213 labelClass != EnumDesc.class) { 214 throw new IllegalArgumentException("label with illegal type found: " + label.getClass()); 215 } 216 } 217 218 /** 219 * Bootstrap method for linking an {@code invokedynamic} call site that 220 * implements a {@code switch} on a target of an enum type. The static 221 * arguments are used to encode the case labels associated to the switch 222 * construct, where each label can be encoded in two ways: 223 * <ul> 224 * <li>as a {@code String} value, which represents the name of 225 * the enum constant associated with the label</li> 226 * <li>as a {@code Class} value, which represents the enum type 227 * associated with a type test pattern</li> 228 * </ul> 229 * <p> 230 * The returned {@code CallSite}'s method handle will have 231 * a return type of {@code int} and accepts two parameters: the first argument 232 * will be an {@code Enum} instance ({@code target}) and the second 233 * will be {@code int} ({@code restart}). 234 * <p> 235 * If the {@code target} is {@code null}, then the method of the call site 236 * returns {@literal -1}. 237 * <p> 238 * If the {@code target} is not {@code null}, then the method of the call site 239 * returns the index of the first element in the {@code labels} array starting from 240 * the {@code restart} index matching one of the following conditions: 241 * <ul> 242 * <li>the element is of type {@code Class} that is assignable 243 * from the target's class; or</li> 244 * <li>the element is of type {@code String} and equals to the target 245 * enum constant's {@link Enum#name()}.</li> 246 * </ul> 247 * <p> 248 * If no element in the {@code labels} array matches the target, then 249 * the method of the call site return the length of the {@code labels} array. 250 * <p> 251 * The value of the {@code restart} index must be between {@code 0} (inclusive) and 252 * the length of the {@code labels} array (inclusive), 253 * both or an {@link IndexOutOfBoundsException} is thrown. 254 * 255 * @param lookup Represents a lookup context with the accessibility 256 * privileges of the caller. When used with {@code invokedynamic}, 257 * this is stacked automatically by the VM. 258 * @param invocationName unused 259 * @param invocationType The invocation type of the {@code CallSite} with two parameters, 260 * an enum type, an {@code int}, and {@code int} as a return type. 261 * @param labels case labels - {@code String} constants and {@code Class} instances, 262 * in any combination 263 * @return a {@code CallSite} returning the first matching element as described above 264 * 265 * @throws NullPointerException if any argument is {@code null} 266 * @throws IllegalArgumentException if any element in the labels array is null, if the 267 * invocation type is not a method type whose first parameter type is an enum type, 268 * second parameter of type {@code int} and whose return type is {@code int}, 269 * or if {@code labels} contains an element that is not of type {@code String} or 270 * {@code Class} of the target enum type. 271 * @jvms 4.4.6 The CONSTANT_NameAndType_info Structure 272 * @jvms 4.4.10 The CONSTANT_Dynamic_info and CONSTANT_InvokeDynamic_info Structures 273 */ 274 public static CallSite enumSwitch(MethodHandles.Lookup lookup, 275 String invocationName, 276 MethodType invocationType, 277 Object... labels) { 278 if (invocationType.parameterCount() != 2 279 || (!invocationType.returnType().equals(int.class)) 280 || invocationType.parameterType(0).isPrimitive() 281 || !invocationType.parameterType(0).isEnum() 282 || !invocationType.parameterType(1).equals(int.class)) 283 throw new IllegalArgumentException("Illegal invocation type " + invocationType); 284 285 labels = labels.clone(); // implicit null check 286 287 Class<?> enumClass = invocationType.parameterType(0); 288 boolean constantsOnly = true; 289 int len = labels.length; 290 291 for (int i = 0; i < len; i++) { 292 Object convertedLabel = 293 convertEnumConstants(lookup, enumClass, labels[i]); 294 labels[i] = convertedLabel; 295 if (constantsOnly) 296 constantsOnly = convertedLabel instanceof EnumDesc; 297 } 298 299 MethodHandle target; 300 301 if (labels.length > 0 && constantsOnly) { 302 //If all labels are enum constants, construct an optimized handle for repeat index 0: 303 //if (selector == null) return -1 304 //else if (idx == 0) return mappingArray[selector.ordinal()]; //mapping array created lazily 305 //else return "typeSwitch(labels)" 306 EnumDesc<?>[] enumDescLabels = 307 Arrays.copyOf(labels, labels.length, EnumDesc[].class); 308 target = MethodHandles.insertArguments(StaticHolders.MAPPED_ENUM_SWITCH, 2, lookup, enumClass, enumDescLabels, new MappedEnumCache()); 309 } else { 310 target = generateTypeSwitch(lookup, invocationType.parameterType(0), labels); 311 } 312 target = target.asType(invocationType); 313 314 return new ConstantCallSite(target); 315 } 316 317 private static <E extends Enum<E>> Object convertEnumConstants(MethodHandles.Lookup lookup, Class<?> enumClassTemplate, Object label) { 318 if (label == null) { 319 throw new IllegalArgumentException("null label found"); 320 } 321 Class<?> labelClass = label.getClass(); 322 if (labelClass == Class.class) { 323 if (label != enumClassTemplate) { 324 throw new IllegalArgumentException("the Class label: " + label + 325 ", expected the provided enum class: " + enumClassTemplate); 326 } 327 return label; 328 } else if (labelClass == String.class) { 329 return EnumDesc.of(referenceClassDesc(enumClassTemplate), (String) label); 330 } else { 331 throw new IllegalArgumentException("label with illegal type found: " + labelClass + 332 ", expected label of type either String or Class"); 333 } 334 } 335 336 private static <T extends Enum<T>> int mappedEnumSwitch(T value, int restartIndex, MethodHandles.Lookup lookup, Class<T> enumClass, EnumDesc<?>[] labels, MappedEnumCache enumCache) throws Throwable { 337 if (value == null) { 338 return -1; 339 } 340 341 if (restartIndex != 0) { 342 MethodHandle generatedSwitch = enumCache.generatedSwitch; 343 if (generatedSwitch == null) { 344 synchronized (enumCache) { 345 generatedSwitch = enumCache.generatedSwitch; 346 347 if (generatedSwitch == null) { 348 generatedSwitch = 349 generateTypeSwitch(lookup, enumClass, labels) 350 .asType(MethodType.methodType(int.class, 351 Enum.class, 352 int.class)); 353 enumCache.generatedSwitch = generatedSwitch; 354 } 355 } 356 } 357 358 return (int) generatedSwitch.invokeExact(value, restartIndex); 359 } 360 361 int[] constantsMap = enumCache.constantsMap; 362 363 if (constantsMap == null) { 364 synchronized (enumCache) { 365 constantsMap = enumCache.constantsMap; 366 367 if (constantsMap == null) { 368 T[] constants = SharedSecrets.getJavaLangAccess() 369 .getEnumConstantsShared(enumClass); 370 constantsMap = new int[constants.length]; 371 int ordinal = 0; 372 373 for (T constant : constants) { 374 constantsMap[ordinal] = labels.length; 375 376 for (int i = 0; i < labels.length; i++) { 377 if (Objects.equals(labels[i].constantName(), 378 constant.name())) { 379 constantsMap[ordinal] = i; 380 break; 381 } 382 } 383 384 ordinal++; 385 } 386 387 enumCache.constantsMap = constantsMap; 388 } 389 } 390 } 391 392 return constantsMap[value.ordinal()]; 393 } 394 395 private static final class ResolvedEnumLabels implements BiPredicate<Integer, Object> { 396 397 private final MethodHandles.Lookup lookup; 398 private final EnumDesc<?>[] enumDescs; 399 @Stable 400 private final Object[] resolvedEnum; 401 402 public ResolvedEnumLabels(MethodHandles.Lookup lookup, EnumDesc<?>[] enumDescs) { 403 this.lookup = lookup; 404 this.enumDescs = enumDescs; 405 this.resolvedEnum = new Object[enumDescs.length]; 406 } 407 408 @Override 409 public boolean test(Integer labelIndex, Object value) { 410 Object result = resolvedEnum[labelIndex]; 411 412 if (result == null) { 413 try { 414 if (!(value instanceof Enum<?> enumValue)) { 415 return false; 416 } 417 418 EnumDesc<?> label = enumDescs[labelIndex]; 419 Class<?> clazz = label.constantType().resolveConstantDesc(lookup); 420 421 if (enumValue.getDeclaringClass() != clazz) { 422 return false; 423 } 424 425 result = label.resolveConstantDesc(lookup); 426 } catch (IllegalArgumentException | ReflectiveOperationException ex) { 427 result = SENTINEL; 428 } 429 430 resolvedEnum[labelIndex] = result; 431 } 432 433 return result == value; 434 } 435 } 436 437 private static final class MappedEnumCache { 438 @Stable 439 public int[] constantsMap; 440 @Stable 441 public MethodHandle generatedSwitch; 442 } 443 444 /** 445 * Check if the labelConstants can be converted statically to bytecode, or 446 * whether we'll need to compute and pass in extra information at the call site. 447 */ 448 private static boolean needsExtraInfo(Class<?> selectorType, Object[] labelConstants) { 449 for (int idx = labelConstants.length - 1; idx >= 0; idx--) { 450 Object currentLabel = labelConstants[idx]; 451 if (currentLabel instanceof Class<?> classLabel) { 452 // No extra info needed for exact matches or primitives 453 if (unconditionalExactnessCheck(selectorType, classLabel) || classLabel.isPrimitive()) { 454 continue; 455 } 456 // Hidden classes - or arrays thereof - can't be nominally 457 // represented. Passed in as arguments. 458 while (classLabel.isArray()) { 459 classLabel = classLabel.getComponentType(); 460 } 461 if (classLabel.isHidden()) { 462 return true; 463 } 464 } else if (currentLabel instanceof EnumDesc<?>) { 465 // EnumDescs labels needs late binding 466 return true; 467 } 468 } 469 return false; 470 } 471 /* 472 * Construct test chains for labels inside switch, to handle switch repeats: 473 * switch (idx) { 474 * case 0 -> if (selector matches label[0]) return 0; 475 * case 1 -> if (selector matches label[1]) return 1; 476 * ... 477 * } 478 */ 479 private static Consumer<CodeBuilder> generateTypeSwitchSkeleton(Class<?> selectorType, Object[] labelConstants, List<EnumDesc<?>> enumDescs, List<Class<?>> extraClassLabels) { 480 int SELECTOR_OBJ = 0; 481 int RESTART_IDX = 1; 482 int ENUM_CACHE = 2; 483 int EXTRA_CLASS_LABELS = 3; 484 485 return cb -> { 486 // Objects.checkIndex(RESTART_IDX, labelConstants + 1) 487 cb.iload(RESTART_IDX); 488 cb.loadConstant(labelConstants.length + 1); 489 cb.invokestatic(CD_Objects, "checkIndex", CHECK_INDEX_DESCRIPTOR); 490 cb.pop(); 491 cb.aload(SELECTOR_OBJ); 492 Label nonNullLabel = cb.newLabel(); 493 cb.ifnonnull(nonNullLabel); 494 cb.iconst_m1(); 495 cb.ireturn(); 496 cb.labelBinding(nonNullLabel); 497 if (labelConstants.length == 0) { 498 cb.loadConstant(0) 499 .ireturn(); 500 return; 501 } 502 cb.iload(RESTART_IDX); 503 Label dflt = cb.newLabel(); 504 Label[] caseTargets = new Label[labelConstants.length]; 505 Label[] caseNext = new Label[labelConstants.length]; 506 Object[] caseLabels = new Object[labelConstants.length]; 507 SwitchCase[] switchCases = new SwitchCase[labelConstants.length]; 508 Object lastLabel = null; 509 for (int idx = labelConstants.length - 1; idx >= 0; idx--) { 510 Object currentLabel = labelConstants[idx]; 511 Label target = cb.newLabel(); 512 Label next; 513 if (lastLabel == null) { 514 next = dflt; 515 } else if (lastLabel.equals(currentLabel)) { 516 next = caseNext[idx + 1]; 517 } else { 518 next = caseTargets[idx + 1]; 519 } 520 lastLabel = currentLabel; 521 caseTargets[idx] = target; 522 caseNext[idx] = next; 523 caseLabels[idx] = currentLabel; 524 switchCases[idx] = SwitchCase.of(idx, target); 525 } 526 cb.tableswitch(0, labelConstants.length - 1, dflt, Arrays.asList(switchCases)); 527 for (int idx = 0; idx < labelConstants.length; idx++) { 528 Label next = caseNext[idx]; 529 Object caseLabel = caseLabels[idx]; 530 cb.labelBinding(caseTargets[idx]); 531 if (caseLabel instanceof Class<?> classLabel) { 532 if (unconditionalExactnessCheck(selectorType, classLabel)) { 533 //nothing - unconditionally use this case 534 } else if (classLabel.isPrimitive()) { 535 if (!selectorType.isPrimitive() && !Wrapper.isWrapperNumericOrBooleanType(selectorType)) { 536 // Object o = ... 537 // o instanceof Wrapped(float) 538 cb.aload(SELECTOR_OBJ); 539 cb.instanceOf(Wrapper.forBasicType(classLabel).wrapperClassDescriptor()); 540 cb.ifeq(next); 541 } else if (!unconditionalExactnessCheck(Wrapper.asPrimitiveType(selectorType), classLabel)) { 542 // Integer i = ... or int i = ... 543 // o instanceof float 544 Label notNumber = cb.newLabel(); 545 cb.aload(SELECTOR_OBJ); 546 cb.instanceOf(ConstantDescs.CD_Number); 547 if (selectorType == long.class || selectorType == float.class || selectorType == double.class || 548 selectorType == Long.class || selectorType == Float.class || selectorType == Double.class) { 549 cb.ifeq(next); 550 } else { 551 cb.ifeq(notNumber); 552 } 553 cb.aload(SELECTOR_OBJ); 554 cb.checkcast(ConstantDescs.CD_Number); 555 if (selectorType == long.class || selectorType == Long.class) { 556 cb.invokevirtual(ConstantDescs.CD_Number, 557 "longValue", 558 MethodTypeDesc.of(ConstantDescs.CD_long)); 559 } else if (selectorType == float.class || selectorType == Float.class) { 560 cb.invokevirtual(ConstantDescs.CD_Number, 561 "floatValue", 562 MethodTypeDesc.of(ConstantDescs.CD_float)); 563 } else if (selectorType == double.class || selectorType == Double.class) { 564 cb.invokevirtual(ConstantDescs.CD_Number, 565 "doubleValue", 566 MethodTypeDesc.of(ConstantDescs.CD_double)); 567 } else { 568 Label compare = cb.newLabel(); 569 cb.invokevirtual(ConstantDescs.CD_Number, 570 "intValue", 571 MethodTypeDesc.of(ConstantDescs.CD_int)); 572 cb.goto_(compare); 573 cb.labelBinding(notNumber); 574 cb.aload(SELECTOR_OBJ); 575 cb.instanceOf(ConstantDescs.CD_Character); 576 cb.ifeq(next); 577 cb.aload(SELECTOR_OBJ); 578 cb.checkcast(ConstantDescs.CD_Character); 579 cb.invokevirtual(ConstantDescs.CD_Character, 580 "charValue", 581 MethodTypeDesc.of(ConstantDescs.CD_char)); 582 cb.labelBinding(compare); 583 } 584 585 TypePairs typePair = TypePairs.of(Wrapper.asPrimitiveType(selectorType), classLabel); 586 String methodName = TypePairs.typePairToName.get(typePair); 587 cb.invokestatic(referenceClassDesc(ExactConversionsSupport.class), 588 methodName, 589 MethodTypeDesc.of(ConstantDescs.CD_boolean, classDesc(typePair.from))); 590 cb.ifeq(next); 591 } 592 } else { 593 Optional<ClassDesc> classLabelConstableOpt = classLabel.describeConstable(); 594 if (classLabelConstableOpt.isPresent()) { 595 cb.aload(SELECTOR_OBJ); 596 cb.instanceOf(classLabelConstableOpt.orElseThrow()); 597 cb.ifeq(next); 598 } else { 599 cb.aload(EXTRA_CLASS_LABELS); 600 cb.loadConstant(extraClassLabels.size()); 601 cb.invokeinterface(ConstantDescs.CD_List, 602 "get", 603 MethodTypeDesc.of(ConstantDescs.CD_Object, 604 ConstantDescs.CD_int)); 605 cb.checkcast(ConstantDescs.CD_Class); 606 cb.aload(SELECTOR_OBJ); 607 cb.invokevirtual(ConstantDescs.CD_Class, 608 "isInstance", 609 MethodTypeDesc.of(ConstantDescs.CD_boolean, 610 ConstantDescs.CD_Object)); 611 cb.ifeq(next); 612 extraClassLabels.add(classLabel); 613 } 614 } 615 } else if (caseLabel instanceof EnumDesc<?> enumLabel) { 616 int enumIdx = enumDescs.size(); 617 enumDescs.add(enumLabel); 618 cb.aload(ENUM_CACHE); 619 cb.loadConstant(enumIdx); 620 cb.invokestatic(ConstantDescs.CD_Integer, 621 "valueOf", 622 MethodTypeDesc.of(ConstantDescs.CD_Integer, 623 ConstantDescs.CD_int)); 624 cb.aload(SELECTOR_OBJ); 625 cb.invokeinterface(CD_BiPredicate, 626 "test", 627 MethodTypeDesc.of(ConstantDescs.CD_boolean, 628 ConstantDescs.CD_Object, 629 ConstantDescs.CD_Object)); 630 cb.ifeq(next); 631 } else if (caseLabel instanceof String stringLabel) { 632 cb.ldc(stringLabel); 633 cb.aload(SELECTOR_OBJ); 634 cb.invokevirtual(ConstantDescs.CD_Object, 635 "equals", 636 MethodTypeDesc.of(ConstantDescs.CD_boolean, 637 ConstantDescs.CD_Object)); 638 cb.ifeq(next); 639 } else if (caseLabel instanceof Integer integerLabel) { 640 Label compare = cb.newLabel(); 641 Label notNumber = cb.newLabel(); 642 cb.aload(SELECTOR_OBJ); 643 cb.instanceOf(ConstantDescs.CD_Number); 644 cb.ifeq(notNumber); 645 cb.aload(SELECTOR_OBJ); 646 cb.checkcast(ConstantDescs.CD_Number); 647 cb.invokevirtual(ConstantDescs.CD_Number, 648 "intValue", 649 MethodTypeDesc.of(ConstantDescs.CD_int)); 650 cb.goto_(compare); 651 cb.labelBinding(notNumber); 652 cb.aload(SELECTOR_OBJ); 653 cb.instanceOf(ConstantDescs.CD_Character); 654 cb.ifeq(next); 655 cb.aload(SELECTOR_OBJ); 656 cb.checkcast(ConstantDescs.CD_Character); 657 cb.invokevirtual(ConstantDescs.CD_Character, 658 "charValue", 659 MethodTypeDesc.of(ConstantDescs.CD_char)); 660 cb.labelBinding(compare); 661 662 cb.loadConstant(integerLabel); 663 cb.if_icmpne(next); 664 } else if ((caseLabel instanceof Long || 665 caseLabel instanceof Float || 666 caseLabel instanceof Double || 667 caseLabel instanceof Boolean)) { 668 if (caseLabel instanceof Boolean c) { 669 cb.loadConstant(c ? 1 : 0); 670 } else { 671 cb.loadConstant((ConstantDesc) caseLabel); 672 } 673 var caseLabelWrapper = Wrapper.forWrapperType(caseLabel.getClass()); 674 cb.invokestatic(caseLabelWrapper.wrapperClassDescriptor(), 675 "valueOf", 676 MethodTypeDesc.of(caseLabelWrapper.wrapperClassDescriptor(), 677 caseLabelWrapper.basicClassDescriptor())); 678 cb.aload(SELECTOR_OBJ); 679 cb.invokevirtual(ConstantDescs.CD_Object, 680 "equals", 681 MethodTypeDesc.of(ConstantDescs.CD_boolean, 682 ConstantDescs.CD_Object)); 683 cb.ifeq(next); 684 } else { 685 throw new InternalError("Unsupported label type: " + 686 caseLabel.getClass()); 687 } 688 cb.loadConstant(idx); 689 cb.ireturn(); 690 } 691 cb.labelBinding(dflt); 692 cb.loadConstant(labelConstants.length); 693 cb.ireturn(); 694 }; 695 } 696 697 /* 698 * Construct the method handle that represents the method int typeSwitch(Object, int, BiPredicate, List) 699 */ 700 private static MethodHandle generateTypeSwitch(MethodHandles.Lookup caller, Class<?> selectorType, Object[] labelConstants) { 701 boolean addExtraInfo = needsExtraInfo(selectorType, labelConstants); 702 List<EnumDesc<?>> enumDescs = addExtraInfo ? new ArrayList<>() : null; 703 List<Class<?>> extraClassLabels = addExtraInfo ? new ArrayList<>() : null; 704 705 byte[] classBytes = ClassFile.of().build(ConstantUtils.binaryNameToDesc(typeSwitchClassName(caller.lookupClass())), 706 clb -> { 707 clb.withFlags(AccessFlag.FINAL, AccessFlag.SUPER, AccessFlag.SYNTHETIC) 708 .withMethodBody("typeSwitch", 709 addExtraInfo ? MTD_TYPE_SWITCH_EXTRA : MTD_TYPE_SWITCH, 710 ClassFile.ACC_FINAL | ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC, 711 generateTypeSwitchSkeleton(selectorType, labelConstants, enumDescs, extraClassLabels)); 712 }); 713 714 try { 715 // this class is linked at the indy callsite; so define a hidden nestmate 716 MethodHandles.Lookup lookup; 717 lookup = caller.defineHiddenClass(classBytes, true, NESTMATE, STRONG); 718 MethodHandle typeSwitch = lookup.findStatic(lookup.lookupClass(), 719 "typeSwitch", 720 addExtraInfo ? MT_TYPE_SWITCH_EXTRA : MT_TYPE_SWITCH); 721 if (addExtraInfo) { 722 typeSwitch = MethodHandles.insertArguments(typeSwitch, 2, new ResolvedEnumLabels(caller, enumDescs.toArray(new EnumDesc<?>[0])), 723 List.copyOf(extraClassLabels)); 724 } 725 return typeSwitch; 726 } catch (Throwable t) { 727 throw new IllegalArgumentException(t); 728 } 729 } 730 731 //based on src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java: 732 private static String typeSwitchClassName(Class<?> targetClass) { 733 String name = targetClass.getName(); 734 if (targetClass.isHidden()) { 735 // use the original class name 736 name = name.replace('/', '_'); 737 } 738 return name + "$$TypeSwitch"; 739 } 740 741 // this method should be in sync with com.sun.tools.javac.code.Types.checkUnconditionallyExactPrimitives 742 private static boolean unconditionalExactnessCheck(Class<?> selectorType, Class<?> targetType) { 743 Wrapper selectorWrapper = Wrapper.forBasicType(selectorType); 744 Wrapper targetWrapper = Wrapper.forBasicType(targetType); 745 if (selectorType.isPrimitive() && targetType.equals(selectorWrapper.wrapperType())) { 746 return true; 747 } 748 else if (selectorType.equals(targetType) || 749 ((selectorType.equals(byte.class) && !targetType.equals(char.class)) || 750 (selectorType.equals(short.class) && (selectorWrapper.isStrictSubRangeOf(targetWrapper))) || 751 (selectorType.equals(char.class) && (selectorWrapper.isStrictSubRangeOf(targetWrapper))) || 752 (selectorType.equals(int.class) && (targetType.equals(double.class) || targetType.equals(long.class))) || 753 (selectorType.equals(float.class) && (selectorWrapper.isStrictSubRangeOf(targetWrapper))))) return true; 754 return false; 755 } 756 757 // TypePairs should be in sync with the corresponding record in Lower 758 record TypePairs(Class<?> from, Class<?> to) { 759 760 private static final Map<TypePairs, String> typePairToName = initialize(); 761 762 public static TypePairs of(Class<?> from, Class<?> to) { 763 if (from == byte.class || from == short.class || from == char.class) { 764 from = int.class; 765 } 766 return new TypePairs(from, to); 767 } 768 769 public int hashCode() { 770 return 31 * from.hashCode() + to.hashCode(); 771 } 772 773 public boolean equals(Object other) { 774 if (other instanceof TypePairs otherPair) { 775 return otherPair.from == from && otherPair.to == to; 776 } 777 return false; 778 } 779 780 public static Map<TypePairs, String> initialize() { 781 Map<TypePairs, String> typePairToName = new HashMap<>(); 782 typePairToName.put(new TypePairs(byte.class, char.class), "isIntToCharExact"); // redirected 783 typePairToName.put(new TypePairs(short.class, byte.class), "isIntToByteExact"); // redirected 784 typePairToName.put(new TypePairs(short.class, char.class), "isIntToCharExact"); // redirected 785 typePairToName.put(new TypePairs(char.class, byte.class), "isIntToByteExact"); // redirected 786 typePairToName.put(new TypePairs(char.class, short.class), "isIntToShortExact"); // redirected 787 typePairToName.put(new TypePairs(int.class, byte.class), "isIntToByteExact"); 788 typePairToName.put(new TypePairs(int.class, short.class), "isIntToShortExact"); 789 typePairToName.put(new TypePairs(int.class, char.class), "isIntToCharExact"); 790 typePairToName.put(new TypePairs(int.class, float.class), "isIntToFloatExact"); 791 typePairToName.put(new TypePairs(long.class, byte.class), "isLongToByteExact"); 792 typePairToName.put(new TypePairs(long.class, short.class), "isLongToShortExact"); 793 typePairToName.put(new TypePairs(long.class, char.class), "isLongToCharExact"); 794 typePairToName.put(new TypePairs(long.class, int.class), "isLongToIntExact"); 795 typePairToName.put(new TypePairs(long.class, float.class), "isLongToFloatExact"); 796 typePairToName.put(new TypePairs(long.class, double.class), "isLongToDoubleExact"); 797 typePairToName.put(new TypePairs(float.class, byte.class), "isFloatToByteExact"); 798 typePairToName.put(new TypePairs(float.class, short.class), "isFloatToShortExact"); 799 typePairToName.put(new TypePairs(float.class, char.class), "isFloatToCharExact"); 800 typePairToName.put(new TypePairs(float.class, int.class), "isFloatToIntExact"); 801 typePairToName.put(new TypePairs(float.class, long.class), "isFloatToLongExact"); 802 typePairToName.put(new TypePairs(double.class, byte.class), "isDoubleToByteExact"); 803 typePairToName.put(new TypePairs(double.class, short.class), "isDoubleToShortExact"); 804 typePairToName.put(new TypePairs(double.class, char.class), "isDoubleToCharExact"); 805 typePairToName.put(new TypePairs(double.class, int.class), "isDoubleToIntExact"); 806 typePairToName.put(new TypePairs(double.class, long.class), "isDoubleToLongExact"); 807 typePairToName.put(new TypePairs(double.class, float.class), "isDoubleToFloatExact"); 808 return typePairToName; 809 } 810 } 811 }