1 /*
   2  * Copyright (c) 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 package java.lang.constant;
  26 
  27 import java.lang.Enum.EnumDesc;
  28 import java.lang.invoke.MethodHandle;
  29 import java.lang.invoke.MethodHandles;
  30 import java.lang.invoke.VarHandle;
  31 import java.lang.invoke.VarHandle.VarHandleDesc;
  32 import java.util.Arrays;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Objects;
  36 import java.util.function.Function;
  37 import java.util.stream.Stream;
  38 
  39 import static java.lang.constant.ConstantDescs.CD_Class;
  40 import static java.lang.constant.ConstantDescs.CD_VarHandle;
  41 import static java.lang.constant.ConstantDescs.DEFAULT_NAME;
  42 import static java.lang.constant.ConstantUtils.EMPTY_CONSTANTDESC;
  43 import static java.lang.constant.ConstantUtils.validateMemberName;
  44 import static java.util.Objects.requireNonNull;
  45 import static java.util.stream.Collectors.joining;
  46 
  47 /**
  48  * A <a href="package-summary.html#nominal">nominal descriptor</a> for a
  49  * dynamic constant (one described in the constant pool with
  50  * {@code Constant_Dynamic_info}.)
  51  *
  52  * <p>Concrete subtypes of {@linkplain DynamicConstantDesc} must be
  53  * <a href="../doc-files/ValueBased.html">value-based</a>.
  54  *
  55  * @param <T> the type of the dynamic constant
  56  *
  57  * @since 12
  58  */
  59 public abstract class DynamicConstantDesc<T>
  60         implements ConstantDesc {
  61 
  62     private final DirectMethodHandleDesc bootstrapMethod;
  63     private final ConstantDesc[] bootstrapArgs;
  64     private final String constantName;
  65     private final ClassDesc constantType;
  66 
  67     private static final Map<MethodHandleDesc, Function<DynamicConstantDesc<?>, ConstantDesc>> canonicalMap
  68             = Map.ofEntries(Map.entry(ConstantDescs.BSM_PRIMITIVE_CLASS, DynamicConstantDesc::canonicalizePrimitiveClass),
  69                             Map.entry(ConstantDescs.BSM_ENUM_CONSTANT, DynamicConstantDesc::canonicalizeEnum),
  70                             Map.entry(ConstantDescs.BSM_NULL_CONSTANT, DynamicConstantDesc::canonicalizeNull),
  71                             Map.entry(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, DynamicConstantDesc::canonicalizeStaticFieldVarHandle),
  72                             Map.entry(ConstantDescs.BSM_VARHANDLE_FIELD, DynamicConstantDesc::canonicalizeFieldVarHandle),
  73                             Map.entry(ConstantDescs.BSM_VARHANDLE_ARRAY, DynamicConstantDesc::canonicalizeArrayVarHandle)
  74     );
  75 
  76     /**
  77      * Creates a nominal descriptor for a dynamic constant.
  78      *
  79      * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
  80      *                        bootstrap method for the constant
  81      * @param constantName The unqualified name that would appear in the {@code NameAndType}
  82      *                     operand of the {@code LDC} for this constant
  83      * @param constantType a {@link ClassDesc} describing the type
  84      *                     that would appear in the {@code NameAndType} operand
  85      *                     of the {@code LDC} for this constant
  86      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
  87      *                      to the bootstrap, that would appear in the
  88      *                      {@code BootstrapMethods} attribute
  89      * @throws NullPointerException if any argument is null
  90      * @throws IllegalArgumentException if the {@code name} has the incorrect
  91      * format
  92      * @jvms 4.2.2 Unqualified Names
  93      */
  94     protected DynamicConstantDesc(DirectMethodHandleDesc bootstrapMethod,
  95                                   String constantName,
  96                                   ClassDesc constantType,
  97                                   ConstantDesc... bootstrapArgs) {
  98         this.bootstrapMethod = requireNonNull(bootstrapMethod);
  99         this.constantName = validateMemberName(requireNonNull(constantName));
 100         this.constantType = requireNonNull(constantType);
 101         this.bootstrapArgs = requireNonNull(bootstrapArgs).clone();
 102 
 103         if (constantName.length() == 0)
 104             throw new IllegalArgumentException("Illegal invocation name: " + constantName);
 105     }
 106 
 107     /**
 108      * Returns a nominal descriptor for a dynamic constant, transforming it into
 109      * a more specific type if the constant bootstrap is a well-known one and a
 110      * more specific nominal descriptor type (e.g., ClassDesc) is available.
 111      *
 112      * <p>Classes whose {@link Constable#describeConstable()} method produce
 113      * a {@linkplain DynamicConstantDesc} with a well-known bootstrap including
 114      * {@link Class} (for instances describing primitive types), {@link Enum},
 115      * and {@link VarHandle}.
 116      *
 117      * <p>Bytecode-reading APIs that process the constant pool and wish to expose
 118      * entries as {@link ConstantDesc} to their callers should generally use this
 119      * method in preference to {@link #ofNamed(DirectMethodHandleDesc, String, ClassDesc, ConstantDesc...)}
 120      * because this may result in a more specific type that can be provided to
 121      * callers.
 122      *
 123      * @param <T> the type of the dynamic constant
 124      * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
 125      *                        bootstrap method for the constant
 126      * @param constantName The unqualified name that would appear in the {@code NameAndType}
 127      *                     operand of the {@code LDC} for this constant
 128      * @param constantType a {@link ClassDesc} describing the type
 129      *                     that would appear in the {@code NameAndType} operand
 130      *                     of the {@code LDC} for this constant
 131      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
 132      *                      to the bootstrap, that would appear in the
 133      *                      {@code BootstrapMethods} attribute
 134      * @return the nominal descriptor
 135      * @throws NullPointerException if any argument is null
 136      * @throws IllegalArgumentException if the {@code name} has the incorrect
 137      * format
 138      * @jvms 4.2.2 Unqualified Names
 139      */
 140     public static<T> ConstantDesc ofCanonical(DirectMethodHandleDesc bootstrapMethod,
 141                                               String constantName,
 142                                               ClassDesc constantType,
 143                                               ConstantDesc[] bootstrapArgs) {
 144         return DynamicConstantDesc.<T>ofNamed(bootstrapMethod, constantName, constantType, bootstrapArgs)
 145                 .tryCanonicalize();
 146     }
 147 
 148     /**
 149      * Returns a nominal descriptor for a dynamic constant.
 150      *
 151      * @param <T> the type of the dynamic constant
 152      * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
 153      *                        bootstrap method for the constant
 154      * @param constantName The unqualified name that would appear in the {@code NameAndType}
 155      *                     operand of the {@code LDC} for this constant
 156      * @param constantType a {@link ClassDesc} describing the type
 157      *                     that would appear in the {@code NameAndType} operand
 158      *                     of the {@code LDC} for this constant
 159      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
 160      *                      to the bootstrap, that would appear in the
 161      *                      {@code BootstrapMethods} attribute
 162      * @return the nominal descriptor
 163      * @throws NullPointerException if any argument is null
 164      * @throws IllegalArgumentException if the {@code name} has the incorrect
 165      * format
 166      * @jvms 4.2.2 Unqualified Names
 167      */
 168 
 169     public static<T> DynamicConstantDesc<T> ofNamed(DirectMethodHandleDesc bootstrapMethod,
 170                                                     String constantName,
 171                                                     ClassDesc constantType,
 172                                                     ConstantDesc... bootstrapArgs) {
 173         return new AnonymousDynamicConstantDesc<>(bootstrapMethod, constantName, constantType, bootstrapArgs);
 174     }
 175 
 176     /**
 177      * Returns a nominal descriptor for a dynamic constant whose name parameter
 178      * is {@link ConstantDescs#DEFAULT_NAME}, and whose type parameter is always
 179      * the same as the bootstrap method return type.
 180      *
 181      * @param <T> the type of the dynamic constant
 182      * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
 183      *                        bootstrap method for the constant
 184      * @param bootstrapArgs {@link ConstantDesc}s describing the static arguments
 185      *                      to the bootstrap, that would appear in the
 186      *                      {@code BootstrapMethods} attribute
 187      * @return the nominal descriptor
 188      * @throws NullPointerException if any argument is null
 189      * @jvms 4.2.2 Unqualified Names
 190      */
 191     public static<T> DynamicConstantDesc<T> of(DirectMethodHandleDesc bootstrapMethod,
 192                                                ConstantDesc... bootstrapArgs) {
 193         return ofNamed(bootstrapMethod, DEFAULT_NAME, bootstrapMethod.invocationType().returnType(), bootstrapArgs);
 194     }
 195 
 196     /**
 197      * Returns a nominal descriptor for a dynamic constant whose bootstrap has
 198      * no static arguments, whose name parameter is {@link ConstantDescs#DEFAULT_NAME},
 199      * and whose type parameter is always the same as the bootstrap method return type.
 200      *
 201      * @param <T> the type of the dynamic constant
 202      * @param bootstrapMethod a {@link DirectMethodHandleDesc} describing the
 203      *                        bootstrap method for the constant
 204      * @return the nominal descriptor
 205      * @throws NullPointerException if any argument is null
 206      */
 207     public static<T> DynamicConstantDesc<T> of(DirectMethodHandleDesc bootstrapMethod) {
 208         return of(bootstrapMethod, EMPTY_CONSTANTDESC);
 209     }
 210 
 211     /**
 212      * Returns the name that would appear in the {@code NameAndType} operand
 213      * of the {@code LDC} for this constant.
 214      *
 215      * @return the constant name
 216      */
 217     public String constantName() {
 218         return constantName;
 219     }
 220 
 221     /**
 222      * Returns a {@link ClassDesc} describing the type that would appear in the
 223      * {@code NameAndType} operand of the {@code LDC} for this constant.
 224      *
 225      * @return the constant type
 226      */
 227     public ClassDesc constantType() {
 228         return constantType;
 229     }
 230 
 231     /**
 232      * Returns a {@link MethodHandleDesc} describing the bootstrap method for
 233      * this constant.
 234      *
 235      * @return the bootstrap method
 236      */
 237     public DirectMethodHandleDesc bootstrapMethod() {
 238         return bootstrapMethod;
 239     }
 240 
 241     /**
 242      * Returns the bootstrap arguments for this constant.
 243      *
 244      * @return the bootstrap arguments
 245      */
 246     public ConstantDesc[] bootstrapArgs() {
 247         return bootstrapArgs.clone();
 248     }
 249 
 250     /**
 251      * Returns the bootstrap arguments for this constant as an immutable {@link List}.
 252      *
 253      * @return a {@link List} of the bootstrap arguments
 254      */
 255     public List<ConstantDesc> bootstrapArgsList() {
 256         return List.of(bootstrapArgs);
 257     }
 258 
 259     @SuppressWarnings("unchecked")
 260     public T resolveConstantDesc(MethodHandles.Lookup lookup) throws ReflectiveOperationException {
 261         try {
 262             MethodHandle bsm = (MethodHandle) bootstrapMethod.resolveConstantDesc(lookup);
 263             if (bsm.type().parameterCount() < 2 ||
 264                 !MethodHandles.Lookup.class.isAssignableFrom(bsm.type().parameterType(0))) {
 265                 throw new BootstrapMethodError(
 266                         "Invalid bootstrap method declared for resolving a dynamic constant: " + bootstrapMethod);
 267             }
 268             Object[] bsmArgs = new Object[3 + bootstrapArgs.length];
 269             bsmArgs[0] = lookup;
 270             bsmArgs[1] = constantName;
 271             bsmArgs[2] = constantType.resolveConstantDesc(lookup);
 272             for (int i = 0; i < bootstrapArgs.length; i++)
 273                 bsmArgs[3 + i] = bootstrapArgs[i].resolveConstantDesc(lookup);
 274 
 275             return (T) bsm.invokeWithArguments(bsmArgs);
 276         } catch (Error e) {
 277             throw e;
 278         } catch (Throwable t) {
 279             throw new BootstrapMethodError(t);
 280         }
 281     }
 282 
 283     private ConstantDesc tryCanonicalize() {
 284         Function<DynamicConstantDesc<?>, ConstantDesc> f = canonicalMap.get(bootstrapMethod);
 285         if (f != null) {
 286             try {
 287                 return f.apply(this);
 288             }
 289             catch (Throwable t) {
 290                 return this;
 291             }
 292         }
 293         return this;
 294     }
 295 
 296     private static ConstantDesc canonicalizeNull(DynamicConstantDesc<?> desc) {
 297         if (desc.bootstrapArgs.length != 0)
 298             return desc;
 299         return ConstantDescs.NULL;
 300     }
 301 
 302     private static ConstantDesc canonicalizeEnum(DynamicConstantDesc<?> desc) {
 303         if (desc.bootstrapArgs.length != 0
 304             || desc.constantName == null)
 305             return desc;
 306         return EnumDesc.of(desc.constantType, desc.constantName);
 307     }
 308 
 309     private static ConstantDesc canonicalizePrimitiveClass(DynamicConstantDesc<?> desc) {
 310         if (desc.bootstrapArgs.length != 0
 311             || !desc.constantType().equals(CD_Class)
 312             || desc.constantName == null)
 313             return desc;
 314         return ClassDesc.ofDescriptor(desc.constantName);
 315     }
 316 
 317     private static ConstantDesc canonicalizeStaticFieldVarHandle(DynamicConstantDesc<?> desc) {
 318         if (desc.bootstrapArgs.length != 2
 319                 || !desc.constantType().equals(CD_VarHandle))
 320             return desc;
 321         return VarHandleDesc.ofStaticField((ClassDesc) desc.bootstrapArgs[0],
 322                                      desc.constantName,
 323                                      (ClassDesc) desc.bootstrapArgs[1]);
 324     }
 325 
 326     private static ConstantDesc canonicalizeFieldVarHandle(DynamicConstantDesc<?> desc) {
 327         if (desc.bootstrapArgs.length != 2
 328             || !desc.constantType().equals(CD_VarHandle))
 329             return desc;
 330         return VarHandleDesc.ofField((ClassDesc) desc.bootstrapArgs[0],
 331                                      desc.constantName,
 332                                      (ClassDesc) desc.bootstrapArgs[1]);
 333     }
 334 
 335     private static ConstantDesc canonicalizeArrayVarHandle(DynamicConstantDesc<?> desc) {
 336         if (desc.bootstrapArgs.length != 1
 337             || !desc.constantType().equals(CD_VarHandle))
 338             return desc;
 339         return VarHandleDesc.ofArray((ClassDesc) desc.bootstrapArgs[0]);
 340     }
 341 
 342     // @@@ To eventually support in canonicalization: DCR with BSM=MHR_METHODHANDLEDESC_ASTYPE becomes AsTypeMHDesc
 343 
 344     /**
 345      * Compares the specified object with this descriptor for equality.  Returns
 346      * {@code true} if and only if the specified object is also a
 347      * {@linkplain DynamicConstantDesc}, and both descriptors have equal
 348      * bootstrap methods, bootstrap argument lists, constant name, and
 349      * constant type.
 350      *
 351      * @param o the {@code DynamicConstantDesc} to compare to this
 352      *       {@code DynamicConstantDesc}
 353      * @return {@code true} if the specified {@code DynamicConstantDesc} is
 354      *      equals to this {@code DynamicConstantDesc}.
 355      *
 356      */
 357     @Override
 358     public final boolean equals(Object o) {
 359         if (this == o) return true;
 360         if (!(o instanceof DynamicConstantDesc)) return false;
 361         DynamicConstantDesc<?> desc = (DynamicConstantDesc<?>) o;
 362         return Objects.equals(bootstrapMethod, desc.bootstrapMethod) &&
 363                Arrays.equals(bootstrapArgs, desc.bootstrapArgs) &&
 364                Objects.equals(constantName, desc.constantName) &&
 365                Objects.equals(constantType, desc.constantType);
 366     }
 367 
 368     @Override
 369     public final int hashCode() {
 370         int result = Objects.hash(bootstrapMethod, constantName, constantType);
 371         result = 31 * result + Arrays.hashCode(bootstrapArgs);
 372         return result;
 373     }
 374 
 375     /**
 376      * Returns a compact textual description of this constant description,
 377      * including the bootstrap method, the constant name and type, and
 378      * the static bootstrap arguments.
 379      *
 380      * @return A compact textual description of this call site descriptor
 381      */
 382     @Override
 383     public String toString() {
 384         return String.format("DynamicConstantDesc[%s::%s(%s%s)%s]",
 385                              bootstrapMethod.owner().displayName(),
 386                              bootstrapMethod.methodName(),
 387                              constantName.equals(ConstantDescs.DEFAULT_NAME) ? "" : constantName + "/",
 388                              Stream.of(bootstrapArgs).map(Object::toString).collect(joining(",")),
 389                              constantType.displayName());
 390     }
 391 
 392     private static class AnonymousDynamicConstantDesc<T> extends DynamicConstantDesc<T> {
 393         AnonymousDynamicConstantDesc(DirectMethodHandleDesc bootstrapMethod, String constantName, ClassDesc constantType, ConstantDesc... bootstrapArgs) {
 394             super(bootstrapMethod, constantName, constantType, bootstrapArgs);
 395         }
 396     }
 397 }