# HG changeset patch # Parent 271ef464fb3a4ae80c345a7234eaa4f90a32aeea 8186216: Use ldc + condy instead of invokedynamic for constant lambdas diff -r 271ef464fb3a make/CompileJavaModules.gmk --- a/make/CompileJavaModules.gmk Thu Mar 22 09:07:08 2018 -0700 +++ b/make/CompileJavaModules.gmk Thu Mar 22 17:39:26 2018 -0400 @@ -268,7 +268,7 @@ ################################################################################ -java.rmi_ADD_JAVAC_FLAGS += -Xdoclint:all/protected '-Xdoclint/package:java.*,javax.*' +java.rmi_ADD_JAVAC_FLAGS += -Xdoclint:all/protected '-Xdoclint/package:java.*,javax.*' -XDforNonCapturingLambda=generateIndy java.rmi_CLEAN_FILES += $(wildcard \ $(TOPDIR)/src/java.rmi/share/classes/sun/rmi/registry/resources/*.properties \ $(TOPDIR)/src/java.rmi/share/classes/sun/rmi/server/resources/*.properties) diff -r 271ef464fb3a src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java --- a/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/java.base/share/classes/java/lang/invoke/AbstractValidatingLambdaMetafactory.java Thu Mar 22 17:39:26 2018 -0400 @@ -187,6 +187,8 @@ c.getName())); } } + + validateMetafactoryArgs(); } /** @@ -203,7 +205,7 @@ * Check the meta-factory arguments for errors * @throws LambdaConversionException if there are improper conversions */ - void validateMetafactoryArgs() throws LambdaConversionException { + private void validateMetafactoryArgs() throws LambdaConversionException { // Check arity: captured + SAM == impl final int implArity = implMethodType.parameterCount(); final int capturedArity = invokedType.parameterCount(); diff -r 271ef464fb3a src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java --- a/src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java Thu Mar 22 17:39:26 2018 -0400 @@ -101,6 +101,7 @@ private final String[] argNames; // Generated names for the constructor arguments private final String[] argDescs; // Type descriptors for the constructor arguments private final String lambdaClassName; // Generated name for the generated class "X$$Lambda$1" + private final Class innerClass; // Lambda proxy class /** * General meta-factory constructor, supporting both standard cases and @@ -152,6 +153,7 @@ super(caller, invokedType, samMethodName, samMethodType, implMethod, instantiatedMethodType, isSerializable, markerInterfaces, additionalBridges); + implMethodClassName = implClass.getName().replace('.', '/'); implMethodName = implInfo.getName(); implMethodDesc = implInfo.getMethodType().toMethodDescriptorString(); @@ -169,6 +171,43 @@ } else { argNames = argDescs = EMPTY_STRING_ARRAY; } + + innerClass = spinInnerClass(); + } + + /** + * Returns an instance of the lambda object for a non-capturing lambda + * or method reference + * + * @return the lambda object + * @throws LambdaConversionException If there was an error creating the + * lambda object + */ + Object buildInstance() throws LambdaConversionException { + final Constructor[] ctrs = AccessController.doPrivileged( + new PrivilegedAction<>() { + @Override + public Constructor[] run() { + Constructor[] ctrs = innerClass.getDeclaredConstructors(); + if (ctrs.length == 1) { + // The lambda implementing inner class constructor is private, set + // it accessible (by us) before creating the constant sole instance + ctrs[0].setAccessible(true); + } + return ctrs; + } + }); + if (ctrs.length != 1) { + throw new LambdaConversionException("Expected one lambda constructor for " + + innerClass.getCanonicalName() + ", got " + ctrs.length); + } + + try { + return ctrs[0].newInstance(); + } + catch (ReflectiveOperationException e) { + throw new LambdaConversionException("Exception instantiating lambda object", e); + } } /** @@ -179,39 +218,13 @@ * * @return a CallSite, which, when invoked, will return an instance of the * functional interface - * @throws ReflectiveOperationException - * @throws LambdaConversionException If properly formed functional interface - * is not found + * @throws LambdaConversionException If there was an error creating the + * lambda factory call site */ @Override CallSite buildCallSite() throws LambdaConversionException { - final Class innerClass = spinInnerClass(); if (invokedType.parameterCount() == 0) { - final Constructor[] ctrs = AccessController.doPrivileged( - new PrivilegedAction<>() { - @Override - public Constructor[] run() { - Constructor[] ctrs = innerClass.getDeclaredConstructors(); - if (ctrs.length == 1) { - // The lambda implementing inner class constructor is private, set - // it accessible (by us) before creating the constant sole instance - ctrs[0].setAccessible(true); - } - return ctrs; - } - }); - if (ctrs.length != 1) { - throw new LambdaConversionException("Expected one lambda constructor for " - + innerClass.getCanonicalName() + ", got " + ctrs.length); - } - - try { - Object inst = ctrs[0].newInstance(); - return new ConstantCallSite(MethodHandles.constant(samBase, inst)); - } - catch (ReflectiveOperationException e) { - throw new LambdaConversionException("Exception instantiating lambda object", e); - } + return new ConstantCallSite(MethodHandles.constant(samBase, buildInstance())); } else { try { UNSAFE.ensureClassInitialized(innerClass); @@ -240,7 +253,7 @@ * @throws LambdaConversionException If properly formed functional interface * is not found */ - private Class spinInnerClass() throws LambdaConversionException { + private Class spinInnerClass() { String[] interfaces; String samIntf = samBase.getName().replace('.', '/'); boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(samBase); diff -r 271ef464fb3a src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java --- a/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java Thu Mar 22 17:39:26 2018 -0400 @@ -314,13 +314,74 @@ MethodHandle implMethod, MethodType instantiatedMethodType) throws LambdaConversionException { - AbstractValidatingLambdaMetafactory mf; - mf = new InnerClassLambdaMetafactory(caller, invokedType, - invokedName, samMethodType, - implMethod, instantiatedMethodType, - false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY); - mf.validateMetafactoryArgs(); - return mf.buildCallSite(); + return new InnerClassLambdaMetafactory(caller, invokedType, + invokedName, samMethodType, + implMethod, instantiatedMethodType, + false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY) + .buildCallSite(); + } + + /** + * Special-case case version of {@link LambdaMetafactory#metafactory(MethodHandles.Lookup, String, Class, MethodType, MethodHandle, MethodType)} + * that is restricted to non-capturing lambdas. Rather than returning a + * {@link CallSite} that is linked to a factory for lambda objects, the + * lambda object itself is returned. + * + *

Typically used as a bootstrap method for {@code Constant_Dynamic} + * constants, to support the lambda expression and method + * reference expression features of the Java Programming Language. + * + *

The function object returned is an instance of a class which + * implements the interface named by {@code functionalInterface}, + * declares a method with the name given by {@code invokedName} and the + * signature given by {@code samMethodType}. It may also override additional + * methods from {@code Object}. + * + * @param caller Represents a lookup context with the accessibility + * privileges of the caller. When used with {@code invokedynamic}, + * this is stacked automatically by the VM. + * @param invokedName The name of the method to implement. When used with + * {@code Dynamic} constants, this is provided by the + * {@code NameAndType} of the {@code InvokeDynamic} + * structure and is stacked automatically by the VM. + * @param functionalInterface The functional interface the function object + * should implement. When used with {@code invokedynamic}, + * this is provided by the {@code NameAndType} of + * the {@code InvokeDynamic} structure and is + * stacked automatically by the VM. In the event + * that the implementation method is an instance + * method and this signature has any parameters, + * the first parameter in the invocation signature + * must correspond to the receiver. + * @param samMethodType Signature and return type of method to be implemented + * by the function object. + * @param implMethod A direct method handle describing the implementation + * method which should be called (with suitable adaptation + * of argument types, return types, and with captured + * arguments prepended to the invocation arguments) at + * invocation time. + * @param instantiatedMethodType The signature and return type that should + * be enforced dynamically at invocation time. + * This may be the same as {@code samMethodType}, + * or may be a specialization of it. + * @return a CallSite whose target can be used to perform capture, generating + * instances of the interface named by {@code invokedType} + * @throws LambdaConversionException If any of the linkage invariants + * described {@link LambdaMetafactory above} + * are violated + */ + public static Object metafactory(MethodHandles.Lookup caller, + String invokedName, + Class functionalInterface, + MethodType samMethodType, + MethodHandle implMethod, + MethodType instantiatedMethodType) + throws LambdaConversionException { + return new InnerClassLambdaMetafactory(caller, MethodType.methodType(functionalInterface), + invokedName, samMethodType, + implMethod, instantiatedMethodType, + false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY) + .buildInstance(); } /** @@ -487,14 +548,12 @@ } } - AbstractValidatingLambdaMetafactory mf - = new InnerClassLambdaMetafactory(caller, invokedType, - invokedName, samMethodType, - implMethod, - instantiatedMethodType, - isSerializable, - markerInterfaces, bridges); - mf.validateMetafactoryArgs(); - return mf.buildCallSite(); + return new InnerClassLambdaMetafactory(caller, invokedType, + invokedName, samMethodType, + implMethod, + instantiatedMethodType, + isSerializable, + markerInterfaces, bridges) + .buildCallSite(); } } diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Source.java Thu Mar 22 17:39:26 2018 -0400 @@ -181,7 +181,8 @@ DIAMOND_WITH_ANONYMOUS_CLASS_CREATION(JDK9, Fragments.FeatureDiamondAndAnonClass, DiagKind.NORMAL), UNDERSCORE_IDENTIFIER(MIN, JDK8), PRIVATE_INTERFACE_METHODS(JDK9, Fragments.FeaturePrivateIntfMethods, DiagKind.PLURAL), - LOCAL_VARIABLE_TYPE_INFERENCE(JDK10); + LOCAL_VARIABLE_TYPE_INFERENCE(JDK10), + CONDY_FOR_LAMBDA(JDK11); enum DiagKind { NORMAL, diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Symbol.java Thu Mar 22 17:39:26 2018 -0400 @@ -1631,6 +1631,10 @@ public R accept(Symbol.Visitor v, P p) { return v.visitVarSymbol(this, p); } + + public boolean isDynamic() { + return false; + } } /** A class for method symbols. @@ -2005,6 +2009,26 @@ } } + /** A class for condy. + */ + public static class DynamicVarSymbol extends VarSymbol { + public Object[] staticArgs; + public MethodSymbol bsm; + public int bsmKind; + + public DynamicVarSymbol(Name name, Symbol owner, int bsmKind, MethodSymbol bsm, Type type, Object[] staticArgs) { + super(0, name, type, owner); + this.bsm = bsm; + this.bsmKind = bsmKind; + this.staticArgs = staticArgs; + } + + @Override + public boolean isDynamic() { + return true; + } + } + /** A class for predefined operators. */ public static class OperatorSymbol extends MethodSymbol { diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java Thu Mar 22 17:39:26 2018 -0400 @@ -35,6 +35,7 @@ import com.sun.tools.javac.code.Symbol; import com.sun.tools.javac.code.Symbol.ClassSymbol; import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol; +import com.sun.tools.javac.code.Symbol.DynamicVarSymbol; import com.sun.tools.javac.code.Symbol.MethodSymbol; import com.sun.tools.javac.code.Symbol.TypeSymbol; import com.sun.tools.javac.code.Symbol.VarSymbol; @@ -70,7 +71,8 @@ import javax.lang.model.element.ElementKind; import javax.lang.model.type.TypeKind; -import com.sun.tools.javac.main.Option; +import com.sun.tools.javac.code.Source; +import com.sun.tools.javac.code.Source.Feature; /** * This pass desugars lambda expressions into static methods @@ -149,6 +151,12 @@ dumpLambdaToMethodStats = options.isSet("debug.dumpLambdaToMethodStats"); attr = Attr.instance(context); forceSerializable = options.isSet("forceSerializable"); + Source source = Source.instance(context); + // format: -XDforNonCapturingLambda=generateCondy, which is the default, or -XDforNonCapturingLambda=generateIndy + String condyOp = options.get("forNonCapturingLambda"); + condyForLambda = condyOp != null ? + condyOp.equals("generateCondy") : + Feature.CONDY_FOR_LAMBDA.allowedInSource(source); } // @@ -1108,8 +1116,53 @@ } } } + return makeDynamicCall(tree, syms.lambdaMetafactory, + metafactoryName, staticArgs, tree.type, indyType, indy_args, samSym.name); + } - return makeIndyCall(tree, syms.lambdaMetafactory, metafactoryName, staticArgs, indyType, indy_args, samSym.name); + private JCExpression makeDynamicCall(DiagnosticPosition pos, Type site, Name bsmName, + List staticArgs, Type interfaceType, MethodType indyType, List indyArgs, + Name methName) { + return condyForLambda && + !context.needsAltMetafactory() && + indyArgs.isEmpty() ? + makeCondy(pos, site, bsmName, staticArgs, interfaceType, methName) : + makeIndyCall(pos, site, bsmName, staticArgs, indyType, indyArgs, methName); + } + + /* this extra flag should be temporary and used as long as it's not possible to do the build + * due to the lack of support for condy in the current version of ASM present in the build + */ + private final boolean condyForLambda; + + private JCExpression makeCondy(DiagnosticPosition pos, Type site, Name bsmName, + List staticArgs, Type interfaceType, Name methName) { + int prevPos = make.pos; + try { + make.at(pos); + List bsm_staticArgs = List.of(syms.methodHandleLookupType, + syms.stringType, + syms.classType).appendList(bsmStaticArgToTypes(staticArgs)); + + Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site, + bsmName, bsm_staticArgs, List.nil()); + + DynamicVarSymbol dynSym = new DynamicVarSymbol(methName, + syms.noSymbol, + bsm.isStatic() ? + ClassFile.REF_invokeStatic : + ClassFile.REF_invokeVirtual, + (MethodSymbol)bsm, + interfaceType, + staticArgs.toArray()); + + JCIdent ident = make.Ident(dynSym); + ident.type = interfaceType; + + return ident; + } finally { + make.at(prevPos); + } } /** diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassWriter.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/ClassWriter.java Thu Mar 22 17:39:26 2018 -0400 @@ -48,7 +48,6 @@ import com.sun.tools.javac.jvm.Pool.Method; import com.sun.tools.javac.jvm.Pool.MethodHandle; import com.sun.tools.javac.jvm.Pool.Variable; -import com.sun.tools.javac.main.Option; import com.sun.tools.javac.util.*; import static com.sun.tools.javac.code.Flags.*; @@ -149,6 +148,9 @@ /** Access to files. */ private final JavaFileManager fileManager; + /** The symbol table. */ + private final Symtab syms; + /** Sole signature generator */ private final CWSignatureGenerator signatureGen; @@ -179,6 +181,7 @@ source = Source.instance(context); types = Types.instance(context); fileManager = context.get(JavaFileManager.class); + syms = Symtab.instance(context); signatureGen = new CWSignatureGenerator(types); verbose = options.isSet(VERBOSE); @@ -393,33 +396,36 @@ poolbuf.appendChar(pool.put(nameType(m))); } else { //invokedynamic + //invokedynamic DynamicMethodSymbol dynSym = (DynamicMethodSymbol)m; MethodHandle handle = new MethodHandle(dynSym.bsmKind, dynSym.bsm, types); - DynamicMethod.BootstrapMethodsKey key = new DynamicMethod.BootstrapMethodsKey(dynSym, types); - - // Figure out the index for existing BSM; create a new BSM if no key - DynamicMethod.BootstrapMethodsValue val = bootstrapMethods.get(key); - if (val == null) { - int index = bootstrapMethods.size(); - val = new DynamicMethod.BootstrapMethodsValue(handle, index); - bootstrapMethods.put(key, val); - } - - //init cp entries - pool.put(names.BootstrapMethods); - pool.put(handle); - for (Object staticArg : dynSym.staticArgs) { - pool.put(staticArg); - } + DynamicMethod.BootstrapMethodsValue val = writeDynSymbol(dynSym, handle); poolbuf.appendByte(CONSTANT_InvokeDynamic); poolbuf.appendChar(val.index); poolbuf.appendChar(pool.put(nameType(dynSym))); } } else if (value instanceof VarSymbol) { VarSymbol v = (VarSymbol)value; - poolbuf.appendByte(CONSTANT_Fieldref); - poolbuf.appendChar(pool.put(v.owner)); - poolbuf.appendChar(pool.put(nameType(v))); + if (!v.isDynamic()) { + poolbuf.appendByte(CONSTANT_Fieldref); + poolbuf.appendChar(pool.put(v.owner)); + poolbuf.appendChar(pool.put(nameType(v))); + } else { + DynamicVarSymbol dynVarSym = (DynamicVarSymbol)v; + MethodHandle handle = new MethodHandle(dynVarSym.bsmKind, dynVarSym.bsm, types); + DynamicMethodSymbol dynSym = new DynamicMethodSymbol( + handle.refSym.name, + syms.noSymbol, + handle.refKind, + (MethodSymbol)handle.refSym, + handle.refSym.type, + dynVarSym.staticArgs); + DynamicMethod.BootstrapMethodsValue val = writeDynSymbol(dynSym, handle); + poolbuf.appendByte(CONSTANT_Dynamic); + poolbuf.appendChar(val.index); + NameAndType nt = new NameAndType(dynVarSym.name, dynVarSym.type, types); + poolbuf.appendChar(pool.put(nt)); + } } else if (value instanceof Name) { poolbuf.appendByte(CONSTANT_Utf8); byte[] bs = ((Name)value).toUtf(); @@ -492,6 +498,25 @@ putChar(poolbuf, poolCountIdx, pool.pp); } + DynamicMethod.BootstrapMethodsValue writeDynSymbol(DynamicMethodSymbol dynSym, MethodHandle handle) { + DynamicMethod.BootstrapMethodsKey key = new DynamicMethod.BootstrapMethodsKey(dynSym, types); + // Figure out the index for existing BSM; create a new BSM if no key + DynamicMethod.BootstrapMethodsValue val = bootstrapMethods.get(key); + if (val == null) { + int index = bootstrapMethods.size(); + val = new DynamicMethod.BootstrapMethodsValue(handle, index); + bootstrapMethods.put(key, val); + } + + //init cp entries + pool.put(names.BootstrapMethods); + pool.put(handle); + for (Object staticArg : dynSym.staticArgs) { + pool.put(staticArg); + } + return val; + } + /** Given a symbol, return its name-and-type. */ NameAndType nameType(Symbol sym) { diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Code.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Code.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Code.java Thu Mar 22 17:39:26 2018 -0400 @@ -919,6 +919,7 @@ if (o instanceof Double) return syms.doubleType; if (o instanceof ClassSymbol) return syms.classType; if (o instanceof Pool.MethodHandle) return syms.methodHandleType; + if (o instanceof Pool.DynamicVariable) return ((Pool.DynamicVariable)o).type; if (o instanceof UniqueType) return typeForPool(((UniqueType)o).type); if (o instanceof Type) { Type ty = (Type) o; diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Gen.java Thu Mar 22 17:39:26 2018 -0400 @@ -811,7 +811,12 @@ // Short circuit any expressions which are constants tree.accept(classReferenceVisitor); checkStringConstant(tree.pos(), tree.type.constValue()); - result = items.makeImmediateItem(tree.type, tree.type.constValue()); + Symbol sym = TreeInfo.symbol(tree); + if (sym != null && isConstantDynamic(sym)) { + result = items.makeDynamicItem(sym); + } else { + result = items.makeImmediateItem(tree.type, tree.type.constValue()); + } } else { this.pt = pt; tree.accept(this); @@ -826,6 +831,12 @@ } } + public boolean isConstantDynamic(Symbol sym) { + return sym.kind == VAR && + sym instanceof DynamicVarSymbol && + ((DynamicVarSymbol)sym).isDynamic(); + } + /** Derived visitor method: generate code for a list of method arguments. * @param trees The argument expressions to be visited. * @param pts The expression's expected types (i.e. the formal parameter @@ -2053,6 +2064,11 @@ res = items.makeMemberItem(sym, true); } result = res; + } else if (isInvokeDynamic(sym) || isConstantDynamic(sym)) { + if (isConstantDynamic(sym)) { + setTypeAnnotationPositions(tree.pos); + } + result = items.makeDynamicItem(sym); } else if (sym.kind == VAR && sym.owner.kind == MTH) { result = items.makeLocalItem((VarSymbol)sym); } else if (isInvokeDynamic(sym)) { diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Items.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Items.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Items.java Thu Mar 22 17:39:26 2018 -0400 @@ -26,9 +26,11 @@ package com.sun.tools.javac.jvm; import com.sun.tools.javac.code.*; +import com.sun.tools.javac.code.Kinds.Kind; import com.sun.tools.javac.code.Symbol.*; import com.sun.tools.javac.code.Type.*; import com.sun.tools.javac.jvm.Code.*; +import com.sun.tools.javac.jvm.Pool.DynamicVariable; import com.sun.tools.javac.tree.JCTree; import com.sun.tools.javac.util.Assert; @@ -155,6 +157,13 @@ return new MemberItem(member, nonvirtual); } + /** Make an item representing a condy. + * @param value The condy value. + */ + Item makeCondyItem(DynamicVariable value) { + return new CondyItem(value); + } + /** Make an item representing a literal. * @param type The literal's type. * @param value The literal's value. @@ -464,6 +473,33 @@ } } + /** An item representing a condy + */ + class CondyItem extends Item { + DynamicVariable value; + + CondyItem(DynamicVariable value) { + super(Code.typecode(value.type)); + this.value = value; + } + + @Override + public String toString() { + return "condy(" + value + ")"; + } + + @Override + Item load() { + int idx = pool.put(value); + if (typecode == LONGcode || typecode == DOUBLEcode) { + code.emitop2(ldc2w, idx); + } else { + code.emitLdc(idx); + } + return stackItem[typecode]; + } + } + /** An item representing a dynamic call site. */ class DynamicItem extends StaticItem { @@ -472,8 +508,11 @@ } Item load() { - assert false; - return null; + Assert.check(member.kind == Kind.VAR); + Type type = member.erasure(types); + int rescode = Code.typecode(type); + code.emitLdc(pool.put(member)); + return stackItem[rescode]; } void store() { @@ -481,7 +520,7 @@ } Item invoke() { - // assert target.hasNativeInvokeDynamic(); + Assert.check(member.kind == Kind.MTH); MethodType mtype = (MethodType)member.erasure(types); int rescode = Code.typecode(mtype.restype); code.emitInvokedynamic(pool.put(member), mtype); diff -r 271ef464fb3a src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Pool.java --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Pool.java Thu Mar 22 09:07:08 2018 -0700 +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/jvm/Pool.java Thu Mar 22 17:39:26 2018 -0400 @@ -39,6 +39,7 @@ import java.util.*; +import com.sun.tools.javac.code.Symtab; import com.sun.tools.javac.util.DefinedBy; import com.sun.tools.javac.util.DefinedBy.Api; @@ -128,6 +129,8 @@ Object makePoolValue(Object o) { if (o instanceof DynamicMethodSymbol) { return new DynamicMethod((DynamicMethodSymbol)o, types); + } else if (o instanceof DynamicVarSymbol) { + return new Pool.DynamicVariable((DynamicVarSymbol)o, types); } else if (o instanceof MethodSymbol) { return new Method((MethodSymbol)o, types); } else if (o instanceof VarSymbol) { @@ -289,6 +292,80 @@ } } + /** + * Pool entry associated with dynamic constants. + */ + public static class DynamicVariable extends Variable { + public MethodHandle bsm; + private Object[] uniqueStaticArgs; + Types types; + + public DynamicVariable(Name name, MethodHandle bsm, Object[] args, Types types, Symtab syms) { + this(name, bsm, bsm.refSym.type.asMethodType().restype, args, types, syms); + } + + public DynamicVariable(Name name, MethodHandle bsm, Type type, Object[] args, Types types, Symtab syms) { + this(new DynamicVarSymbol(name, + syms.noSymbol, + bsm.refKind, + (MethodSymbol)bsm.refSym, + type, + args), types, bsm); + } + + public DynamicVariable(DynamicVarSymbol dynField, Types types) { + this(dynField, types, null); + } + + private DynamicVariable(DynamicVarSymbol dynField, Types types, MethodHandle bsm) { + super(dynField, types); + this.bsm = bsm != null ? + bsm : + new MethodHandle(dynField.bsmKind, dynField.bsm, types); + this.types = types; + uniqueStaticArgs = getUniqueTypeArray(staticArgs(), types); + } + + private Object[] getUniqueTypeArray(Object[] objects, Types types) { + Object[] result = new Object[objects.length]; + for (int i = 0; i < objects.length; i++) { + if (objects[i] instanceof Type) { + result[i] = new UniqueType((Type)objects[i], types); + } else { + result[i] = objects[i]; + } + } + return result; + } + + @Override + public int hashCode() { + int hash = bsm.hashCode() * 67 + other.name.hashCode() + type.hashCode() * 13 + uniqueType.hashCode(); + for (Object uniqueStaticArg : uniqueStaticArgs) { + hash += (uniqueStaticArg.hashCode() * 23); + } + return hash; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof DynamicVariable) { + DynamicVariable that = (DynamicVariable)obj; + return that.bsm.equals(bsm) && + types.isSameType(that.type, type) && + that.other.name.equals(other.name) && + Arrays.equals(uniqueStaticArgs, that.uniqueStaticArgs) && + that.uniqueType.equals(uniqueType); + } else { + return false; + } + } + + public Object[] staticArgs() { + return ((DynamicVarSymbol)other).staticArgs; + } + } + public static class MethodHandle { /** Reference kind - see ClassFile */ diff -r 271ef464fb3a test/langtools/tools/javac/lambda_condy/CheckCondyGeneratedForLambdaTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/langtools/tools/javac/lambda_condy/CheckCondyGeneratedForLambdaTest.java Thu Mar 22 17:39:26 2018 -0400 @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test 8186216 + * @summary check that an LDC + condy is generated for a non-capturing lambda + * @library /tools/lib + * @modules jdk.jdeps/com.sun.tools.classfile + * jdk.compiler/com.sun.tools.javac.api + * jdk.compiler/com.sun.tools.javac.main + * jdk.compiler/com.sun.tools.javac.util + * jdk.jdeps/com.sun.tools.javap + * @build toolbox.ToolBox toolbox.JavacTask + * @run main CheckCondyGeneratedForLambdaTest + */ + +import java.io.File; +import java.nio.file.Paths; + +import com.sun.tools.classfile.ClassFile; +import com.sun.tools.classfile.Code_attribute; +import com.sun.tools.classfile.ConstantPool.*; +import com.sun.tools.classfile.Method; +import com.sun.tools.classfile.Opcode; +import com.sun.tools.javac.util.Assert; + +import toolbox.JavacTask; +import toolbox.ToolBox; + +public class CheckCondyGeneratedForLambdaTest { + + static final String testSource = + "import java.util.stream.*;\n" + + + "public class CondyForLambdaSmokeTest {\n" + + " void lookForThisMethod() {\n" + + " IntStream.of(1,2,3).reduce((a,b) -> a+b);\n" + + " }\n" + + "}"; + + static final String methodToLookFor = "lookForThisMethod"; + static final int LDCByteCodePos = 18; + + public static void main(String[] args) throws Exception { + new CheckCondyGeneratedForLambdaTest().run(); + } + + ToolBox tb = new ToolBox(); + + void run() throws Exception { + compileTestClass(); + checkClassFile(new File(Paths.get(System.getProperty("user.dir"), + "CondyForLambdaSmokeTest.class").toUri()), methodToLookFor); + } + + void compileTestClass() throws Exception { + new JavacTask(tb) + .sources(testSource) + .run(); + } + + void checkClassFile(final File cfile, String methodToFind) throws Exception { + ClassFile classFile = ClassFile.read(cfile); + boolean methodFound = false; + for (Method method : classFile.methods) { + if (method.getName(classFile.constant_pool).equals(methodToFind)) { + methodFound = true; + Code_attribute code = (Code_attribute) method.attributes.get("Code"); + int cpIndex = code.getUnsignedByte(LDCByteCodePos + 1); + Assert.check(code.getUnsignedByte(LDCByteCodePos) == Opcode.LDC.opcode, "ldc was expected"); + CPInfo cpInfo = classFile.constant_pool.get(cpIndex); + Assert.check(cpInfo instanceof CONSTANT_Dynamic_info, "condy argument to ldc was expected"); + } + } + Assert.check(methodFound, "The seek method was not found"); + } + + void error(String msg) { + throw new AssertionError(msg); + } +} diff -r 271ef464fb3a test/langtools/tools/javac/lambda_condy/CheckForCondyDuplicatesTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/langtools/tools/javac/lambda_condy/CheckForCondyDuplicatesTest.java Thu Mar 22 17:39:26 2018 -0400 @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test 8186216 + * @summary check that javac is not generating duplicate condys + * @library /tools/lib + * @modules jdk.jdeps/com.sun.tools.classfile + * jdk.compiler/com.sun.tools.javac.api + * jdk.compiler/com.sun.tools.javac.main + * jdk.compiler/com.sun.tools.javac.util + * jdk.jdeps/com.sun.tools.javap + * @build toolbox.ToolBox toolbox.JavacTask + * @run main CheckForCondyDuplicatesTest + */ + +import java.io.File; +import java.nio.file.Paths; +import java.lang.invoke.constant.*; + +import com.sun.tools.classfile.ClassFile; +import com.sun.tools.classfile.ConstantPool.*; +import com.sun.tools.javac.util.Assert; + +import toolbox.JavacTask; +import toolbox.ToolBox; + +public class CheckForCondyDuplicatesTest { + + static final String testSource1 = + "import java.lang.invoke.constant.*;\n" + + "import java.lang.invoke.*;\n" + + + "public class Test1 {\n" + + " void m() {\n" + + " Object o1 = Intrinsics.ldc(ConstantRefs.NULL);\n" + + " Object o2 = Intrinsics.ldc(ConstantRefs.NULL);\n" + + " }\n" + + "}"; + + static final String testSource2 = + "class Test2 {\n" + + " Runnable r = Test2::foo;\n" + + " Runnable k = Test2::foo;\n" + + " static void foo() {}\n" + + "}"; + + public static void main(String[] args) throws Exception { + new CheckForCondyDuplicatesTest().run(); + } + + ToolBox tb = new ToolBox(); + + void run() throws Exception { + compileTestClass(testSource1); + checkClassFile(new File(Paths.get(System.getProperty("user.dir"), "Test1.class").toUri())); + + compileTestClass(testSource2); + checkClassFile(new File(Paths.get(System.getProperty("user.dir"), "Test2.class").toUri())); + } + + void compileTestClass(String source) throws Exception { + new JavacTask(tb) + .options("-XDdoConstantFold") + .sources(source) + .run(); + } + + void checkClassFile(final File cfile) throws Exception { + ClassFile classFile = ClassFile.read(cfile); + int numberOfCondys = 0; + for (CPInfo cpInfo : classFile.constant_pool.entries()) { + if (cpInfo instanceof CONSTANT_Dynamic_info) { + numberOfCondys++; + } + } + Assert.check(numberOfCondys > 0, "there should be at least one condy in the class file"); + Assert.check(numberOfCondys == 1, "the CP has duplicate condys"); + } +} diff -r 271ef464fb3a test/langtools/tools/javac/lambda_condy/LambdaSerializationTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/langtools/tools/javac/lambda_condy/LambdaSerializationTest.java Thu Mar 22 17:39:26 2018 -0400 @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test 8186216 + * @summary check that serializable lambdas work independently of the serialization approach + * @library /tools/lib + * @modules jdk.jdeps/com.sun.tools.classfile + * jdk.compiler/com.sun.tools.javac.api + * jdk.compiler/com.sun.tools.javac.main + * jdk.compiler/com.sun.tools.javac.util + * jdk.jdeps/com.sun.tools.javap + * @build toolbox.ToolBox toolbox.JavacTask + * @run main LambdaSerializationTest + */ + +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Path; +import java.nio.file.Paths; + +import com.sun.tools.javac.util.Assert; +import toolbox.JavacTask; +import toolbox.ToolBox; + +public class LambdaSerializationTest { + private static final String source = + "import java.io.Serializable;\n" + + "import java.util.function.*;\n" + + "public class Test {\n" + + " public static String foo() {\n" + + " Function f = (Function & Serializable)(s) -> s;\n" + + " return f.apply(\"From serializable lambda\");\n" + + " }\n" + + "}"; + + static final String testOut = System.getProperty("user.dir"); + + public static void main(String... args) throws Throwable { + new LambdaSerializationTest().run(); + } + + ToolBox tb = new ToolBox(); + + void run() throws Throwable { + compileTestClass(false); + String res1 = loadAndInvoke(); + compileTestClass(true); + String res2 = loadAndInvoke(); + Assert.check(res1.equals(res2)); + Assert.check(res1.equals("From serializable lambda")); + } + + void compileTestClass(boolean generateCondy) throws Throwable { + String option = generateCondy ? "-XDforNonCapturingLambda=generateCondy" : "-XDforNonCapturingLambda=generateIndy"; + new JavacTask(tb) + .options(option) + .sources(source) + .run(); + } + + String loadAndInvoke() throws Throwable { + Path path = Paths.get(testOut); + System.out.println(path); + ClassLoader cl = new URLClassLoader(new URL[] { path.toUri().toURL() }); + Class testClass = cl.loadClass("Test"); + Method theMethod = testClass.getDeclaredMethod("foo", new Class[0]); + return (String)theMethod.invoke(null, new Object[0]); + } +}