8355775: Improve symbolic sharing in dynamic constant pool entries

liach · liach · commit d7e648bb2737 · 2025-05-07T14:08:21.000Z
Reviewed-by: asotona
diff --git a/src/java.base/share/classes/java/lang/classfile/CodeBuilder.java b/src/java.base/share/classes/java/lang/classfile/CodeBuilder.java
@@ -2483,7 +2483,7 @@ default CodeBuilder invokedynamic(DynamicCallSiteDesc ref) {
         var cpArgs = ref.bootstrapArgs();
         List<LoadableConstantEntry> bsArguments = new ArrayList<>(cpArgs.length);
         for (var constantValue : cpArgs) {
-            bsArguments.add(BytecodeHelpers.constantEntry(constantPool(), constantValue));
+            bsArguments.add(constantPool().loadableConstantEntry(requireNonNull(constantValue)));
         }
         BootstrapMethodEntry bm = constantPool().bsmEntry(bsMethod, bsArguments);
         NameAndTypeEntry nameAndType = constantPool().nameAndTypeEntry(ref.invocationName(), ref.invocationType());
@@ -2941,7 +2941,7 @@ default CodeBuilder lconst_1() {
      * @see ConstantInstruction.LoadConstantInstruction
      */
     default CodeBuilder ldc(ConstantDesc value) {
-        return ldc(BytecodeHelpers.constantEntry(constantPool(), value));
+        return ldc(constantPool().loadableConstantEntry(requireNonNull(value)));
     }
 
     /**
diff --git a/src/java.base/share/classes/java/lang/classfile/constantpool/ConstantPoolBuilder.java b/src/java.base/share/classes/java/lang/classfile/constantpool/ConstantPoolBuilder.java
@@ -36,6 +36,7 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+import jdk.internal.classfile.impl.AbstractPoolEntry;
 import jdk.internal.classfile.impl.AbstractPoolEntry.ClassEntryImpl;
 import jdk.internal.classfile.impl.ClassReaderImpl;
 import jdk.internal.classfile.impl.SplitConstantPool;
@@ -385,11 +386,13 @@ default InterfaceMethodRefEntry interfaceMethodRefEntry(ClassDesc owner, String
     default MethodHandleEntry methodHandleEntry(DirectMethodHandleDesc descriptor) {
         var owner = classEntry(descriptor.owner());
         var nat = nameAndTypeEntry(utf8Entry(descriptor.methodName()), utf8Entry(descriptor.lookupDescriptor()));
-        return methodHandleEntry(descriptor.refKind(), switch (descriptor.kind()) {
+        var ret = methodHandleEntry(descriptor.refKind(), switch (descriptor.kind()) {
             case GETTER, SETTER, STATIC_GETTER, STATIC_SETTER -> fieldRefEntry(owner, nat);
             case INTERFACE_STATIC, INTERFACE_VIRTUAL, INTERFACE_SPECIAL -> interfaceMethodRefEntry(owner, nat);
             case STATIC, VIRTUAL, SPECIAL, CONSTRUCTOR -> methodRefEntry(owner, nat);
         });
+        ((AbstractPoolEntry.MethodHandleEntryImpl) ret).sym = descriptor;
+        return ret;
     }
 
     /**
@@ -414,7 +417,9 @@ default MethodHandleEntry methodHandleEntry(DirectMethodHandleDesc descriptor) {
      * @see InvokeDynamicEntry#asSymbol() InvokeDynamicEntry::asSymbol
      */
     default InvokeDynamicEntry invokeDynamicEntry(DynamicCallSiteDesc dcsd) {
-        return invokeDynamicEntry(bsmEntry((DirectMethodHandleDesc)dcsd.bootstrapMethod(), List.of(dcsd.bootstrapArgs())), nameAndTypeEntry(dcsd.invocationName(), dcsd.invocationType()));
+        var ret = invokeDynamicEntry(bsmEntry((DirectMethodHandleDesc)dcsd.bootstrapMethod(), List.of(dcsd.bootstrapArgs())), nameAndTypeEntry(dcsd.invocationName(), dcsd.invocationType()));
+        ((AbstractPoolEntry.InvokeDynamicEntryImpl) ret).sym = dcsd;
+        return ret;
     }
 
     /**
@@ -440,7 +445,9 @@ InvokeDynamicEntry invokeDynamicEntry(BootstrapMethodEntry bootstrapMethodEntry,
      * @see ConstantDynamicEntry#asSymbol() ConstantDynamicEntry::asSymbol
      */
     default ConstantDynamicEntry constantDynamicEntry(DynamicConstantDesc<?> dcd) {
-        return constantDynamicEntry(bsmEntry(dcd.bootstrapMethod(), List.of(dcd.bootstrapArgs())), nameAndTypeEntry(dcd.constantName(), dcd.constantType()));
+        var ret = constantDynamicEntry(bsmEntry(dcd.bootstrapMethod(), List.of(dcd.bootstrapArgs())), nameAndTypeEntry(dcd.constantName(), dcd.constantType()));
+        ((AbstractPoolEntry.ConstantDynamicEntryImpl) ret).sym = dcd;
+        return ret;
     }
 
     /**
diff --git a/src/java.base/share/classes/jdk/internal/classfile/impl/AbstractPoolEntry.java b/src/java.base/share/classes/jdk/internal/classfile/impl/AbstractPoolEntry.java
@@ -295,9 +295,13 @@ private ConstantPoolException malformedInput(int px) {
 
         @Override
         public Utf8EntryImpl clone(ConstantPoolBuilder cp) {
-            return (state == State.STRING && rawBytes == null)
+            var ret = (state == State.STRING && rawBytes == null)
                    ? (Utf8EntryImpl) cp.utf8Entry(stringValue)
                    : ((SplitConstantPool) cp).maybeCloneUtf8Entry(this);
+            var mySym = this.typeSym;
+            if (ret.typeSym == null && mySym != null)
+                ret.typeSym = mySym;
+            return ret;
         }
 
         @Override
@@ -939,6 +943,8 @@ public static final class InvokeDynamicEntryImpl
             extends AbstractDynamicConstantPoolEntry
             implements InvokeDynamicEntry {
 
+        public @Stable DynamicCallSiteDesc sym;
+
         InvokeDynamicEntryImpl(ConstantPool cpm, int index, int hash, BootstrapMethodEntryImpl bootstrapMethod,
                                    NameAndTypeEntryImpl nameAndType) {
             super(cpm, index, hash, bootstrapMethod, nameAndType);
@@ -957,13 +963,27 @@ public int tag() {
 
         @Override
         public InvokeDynamicEntry clone(ConstantPoolBuilder cp) {
-            return cp.invokeDynamicEntry(bootstrap(), nameAndType());
+            var ret = (InvokeDynamicEntryImpl) cp.invokeDynamicEntry(bootstrap(), nameAndType());
+            var mySym = this.sym;
+            if (ret.sym == null && mySym != null)
+                ret.sym = mySym;
+            return ret;
+        }
+
+        @Override
+        public DynamicCallSiteDesc asSymbol() {
+            var cache = this.sym;
+            if (cache != null)
+                return cache;
+            return this.sym = InvokeDynamicEntry.super.asSymbol();
         }
     }
 
     public static final class ConstantDynamicEntryImpl extends AbstractDynamicConstantPoolEntry
             implements ConstantDynamicEntry {
 
+        public @Stable DynamicConstantDesc<?> sym;
+
         ConstantDynamicEntryImpl(ConstantPool cpm, int index, int hash, BootstrapMethodEntryImpl bootstrapMethod,
                                      NameAndTypeEntryImpl nameAndType) {
             super(cpm, index, hash, bootstrapMethod, nameAndType);
@@ -982,7 +1002,19 @@ public int tag() {
 
         @Override
         public ConstantDynamicEntry clone(ConstantPoolBuilder cp) {
-            return cp.constantDynamicEntry(bootstrap(), nameAndType());
+            var ret = (ConstantDynamicEntryImpl) cp.constantDynamicEntry(bootstrap(), nameAndType());
+            var mySym = this.sym;
+            if (ret.sym == null && mySym != null)
+                ret.sym = mySym;
+            return ret;
+        }
+
+        @Override
+        public DynamicConstantDesc<?> asSymbol() {
+            var cache = this.sym;
+            if (cache != null)
+                return cache;
+            return this.sym = ConstantDynamicEntry.super.asSymbol();
         }
     }
 
@@ -991,6 +1023,7 @@ public static final class MethodHandleEntryImpl extends AbstractPoolEntry
 
         private final int refKind;
         private final AbstractPoolEntry.AbstractMemberRefEntry reference;
+        public @Stable DirectMethodHandleDesc sym;
 
         MethodHandleEntryImpl(ConstantPool cpm, int index, int hash, int refKind, AbstractPoolEntry.AbstractMemberRefEntry
                 reference) {
@@ -1023,7 +1056,14 @@ public AbstractPoolEntry.AbstractMemberRefEntry reference() {
 
         @Override
         public DirectMethodHandleDesc asSymbol() {
-            return MethodHandleDesc.of(
+            var cache = this.sym;
+            if (cache != null)
+                return cache;
+            return computeSymbol();
+        }
+
+        private DirectMethodHandleDesc computeSymbol() {
+            return this.sym = MethodHandleDesc.of(
                     DirectMethodHandleDesc.Kind.valueOf(kind(), reference() instanceof InterfaceMethodRefEntry),
                     ((MemberRefEntry) reference()).owner().asSymbol(),
                     ((MemberRefEntry) reference()).nameAndType().name().stringValue(),
@@ -1037,7 +1077,11 @@ void writeTo(BufWriterImpl pool) {
 
         @Override
         public MethodHandleEntry clone(ConstantPoolBuilder cp) {
-            return cp.methodHandleEntry(refKind, reference);
+            var ret = (MethodHandleEntryImpl) cp.methodHandleEntry(refKind, reference);
+            var mySym = this.sym;
+            if (ret.sym == null && mySym != null)
+                ret.sym = mySym;
+            return ret;
         }
 
         @Override
diff --git a/src/java.base/share/classes/jdk/internal/classfile/impl/BytecodeHelpers.java b/src/java.base/share/classes/jdk/internal/classfile/impl/BytecodeHelpers.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2024, Alibaba Group Holding Limited. All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -29,12 +29,10 @@
 import java.lang.classfile.Opcode;
 import java.lang.classfile.TypeKind;
 import java.lang.classfile.constantpool.*;
-import java.lang.constant.ClassDesc;
 import java.lang.constant.ConstantDesc;
 import java.lang.constant.ConstantDescs;
 import java.lang.constant.DirectMethodHandleDesc;
 import java.lang.constant.DynamicConstantDesc;
-import java.lang.constant.MethodTypeDesc;
 import java.lang.invoke.MethodHandleInfo;
 import java.util.ArrayList;
 import java.util.List;
@@ -515,38 +513,6 @@ public static Opcode ldcOpcode(LoadableConstantEntry entry) {
                 : Opcode.LDC;
     }
 
-    public static LoadableConstantEntry constantEntry(ConstantPoolBuilder constantPool,
-                                                      ConstantDesc constantValue) {
-        // this method is invoked during JVM bootstrap - cannot use pattern switch
-        if (constantValue instanceof Integer value) {
-            return constantPool.intEntry(value);
-        }
-        if (constantValue instanceof String value) {
-            return constantPool.stringEntry(value);
-        }
-        if (constantValue instanceof ClassDesc value && !value.isPrimitive()) {
-            return constantPool.classEntry(value);
-        }
-        if (constantValue instanceof Long value) {
-            return constantPool.longEntry(value);
-        }
-        if (constantValue instanceof Float value) {
-            return constantPool.floatEntry(value);
-        }
-        if (constantValue instanceof Double value) {
-            return constantPool.doubleEntry(value);
-        }
-        if (constantValue instanceof MethodTypeDesc value) {
-            return constantPool.methodTypeEntry(value);
-        }
-        if (constantValue instanceof DirectMethodHandleDesc value) {
-            return handleDescToHandleInfo(constantPool, value);
-        } if (constantValue instanceof DynamicConstantDesc<?> value) {
-            return handleConstantDescToHandleInfo(constantPool, value);
-        }
-        throw new UnsupportedOperationException("not yet: " + requireNonNull(constantValue));
-    }
-
     public static ConstantDesc intrinsicConstantValue(Opcode opcode) {
         return switch (opcode) {
             case ACONST_NULL -> ConstantDescs.NULL;
diff --git a/src/java.base/share/classes/jdk/internal/classfile/impl/SplitConstantPool.java b/src/java.base/share/classes/jdk/internal/classfile/impl/SplitConstantPool.java
@@ -30,6 +30,7 @@
 import java.lang.classfile.attribute.BootstrapMethodsAttribute;
 import java.lang.classfile.constantpool.*;
 import java.lang.constant.ClassDesc;
+import java.lang.constant.DynamicCallSiteDesc;
 import java.lang.constant.MethodTypeDesc;
 import java.util.Arrays;
 import java.util.List;
@@ -521,6 +522,10 @@ public ClassEntry classEntry(ClassDesc cd) {
     AbstractPoolEntry.ClassEntryImpl cloneClassEntry(AbstractPoolEntry.ClassEntryImpl e) {
         var ce = tryFindClassEntry(e.hashCode(), e.ref1);
         if (ce != null) {
+            var mySym = e.sym;
+            if (ce.sym == null && mySym != null) {
+                ce.sym = mySym;
+            }
             return ce;
         }
 
diff --git a/src/java.base/share/classes/jdk/internal/classfile/impl/StackMapGenerator.java b/src/java.base/share/classes/jdk/internal/classfile/impl/StackMapGenerator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2024, Alibaba Group Holding Limited. All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -716,7 +716,7 @@ private void processLdc(int index) {
             case TAG_METHOD_TYPE ->
                 currentFrame.pushStack(Type.METHOD_TYPE);
             case TAG_DYNAMIC ->
-                currentFrame.pushStack(cp.entryByIndex(index, ConstantDynamicEntry.class).asSymbol().constantType());
+                currentFrame.pushStack(cp.entryByIndex(index, ConstantDynamicEntry.class).typeSymbol());
             default ->
                 throw generatorError("CP entry #%d %s is not loadable constant".formatted(index, cp.entryByIndex(index).tag()));
         }
