jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java

equal deleted inserted replaced

-:82752776be2f
+:6af4511ee5a4
 el.add(new RecipeElement(cnst));
 } else if (c == TAG_ARG) {
 el.add(new RecipeElement(argC++));
 }
 } else {
-// Not a special characters, this is a constant embedded into
+// Not a special character, this is a constant embedded into
 // the recipe itself.
 acc.append(c);
 }
 }
 }
 private static final class RecipeElement {
 private final Object value;
 private final int argPos;
+private final char tag;
 public RecipeElement(Object cnst) {
 this.value = Objects.requireNonNull(cnst);
 this.argPos = -1;
+this.tag = TAG_CONST;
 }
 public RecipeElement(int arg) {
 this.value = null;
-assert (arg >= 0);
 this.argPos = arg;
+this.tag = TAG_ARG;
 }
 public Object getValue() {
-assert (isConst());
+assert (tag == TAG_CONST);
 return value;
 }
 public int getArgPos() {
-assert (!isConst());
+assert (tag == TAG_ARG);
 return argPos;
 }
-public boolean isConst() {
+public char getTag() {
-return argPos == -1;
+return tag;
 }
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
 RecipeElement that = (RecipeElement) o;
-boolean isConst = isConst();
+if (this.tag != that.tag) return false;
-if (isConst != that.isConst()) return false;
+if (this.tag == TAG_CONST && (!value.equals(that.value))) return false;
-if (isConst && (!value.equals(that.value))) return false;
+if (this.tag == TAG_ARG && (argPos != that.argPos)) return false;
-if (!isConst && (argPos != that.argPos)) return false;
 return true;
 }
 @Override
 public int hashCode() {
-return argPos;
+return (int)tag;
 }
 }
 /**
 * Facilitates the creation of optimized String concatenation methods, that
 *
 * @param args actual argument types
 * @return argument types the strategy is going to use
 */
 private static MethodType adaptType(MethodType args) {
-Class<?>[] ptypes = args.parameterArray();
+Class<?>[] ptypes = null;
-boolean changed = false;
+for (int i = 0; i < args.parameterCount(); i++) {
-for (int i = 0; i < ptypes.length; i++) {
+Class<?> ptype = args.parameterType(i);
-Class<?> ptype = ptypes[i];
 if (!ptype.isPrimitive() &&
 ptype != String.class &&
 ptype != Object.class) { // truncate to Object
+if (ptypes == null) {
+ptypes = args.parameterArray();
+}
 ptypes[i] = Object.class;
-changed = true;
 }
 // else other primitives or String or Object (unchanged)
 }
-return changed
+return (ptypes != null)
 ? MethodType.methodType(args.returnType(), ptypes)
 : args;
 }
 private static String getClassName(Class<?> hostClass) throws StringConcatException {
 need to do null-checks early, not make the append chain shape simpler.
 */
 int off = 0;
 for (RecipeElement el : recipe.getElements()) {
-if (el.isConst()) {
+switch (el.getTag()) {
-// Guaranteed non-null, no null check required.
+case TAG_CONST:
-} else {
+// Guaranteed non-null, no null check required.
-// Null-checks are needed only for String arguments, and when a previous stage
+break;
-// did not do implicit null-checks. If a String is null, we eagerly replace it
+case TAG_ARG:
-// with "null" constant. Note, we omit Objects here, because we don't call
+// Null-checks are needed only for String arguments, and when a previous stage
-// .length() on them down below.
+// did not do implicit null-checks. If a String is null, we eagerly replace it
-int ac = el.getArgPos();
+// with "null" constant. Note, we omit Objects here, because we don't call
-Class<?> cl = arr[ac];
+// .length() on them down below.
-if (cl == String.class && !guaranteedNonNull[ac]) {
+int ac = el.getArgPos();
-Label l0 = new Label();
+Class<?> cl = arr[ac];
-mv.visitIntInsn(ALOAD, off);
+if (cl == String.class && !guaranteedNonNull[ac]) {
-mv.visitJumpInsn(IFNONNULL, l0);
+Label l0 = new Label();
-mv.visitLdcInsn("null");
+mv.visitIntInsn(ALOAD, off);
-mv.visitIntInsn(ASTORE, off);
+mv.visitJumpInsn(IFNONNULL, l0);
-mv.visitLabel(l0);
+mv.visitLdcInsn("null");
-}
+mv.visitIntInsn(ASTORE, off);
-off += getParameterSize(cl);
+mv.visitLabel(l0);
+}
+off += getParameterSize(cl);
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 }
 }
 // Prepare StringBuilder instance
 int off = 0;
 mv.visitInsn(ICONST_0);
 for (RecipeElement el : recipe.getElements()) {
-if (el.isConst()) {
+switch (el.getTag()) {
-Object cnst = el.getValue();
+case TAG_CONST:
-len += cnst.toString().length();
+Object cnst = el.getValue();
-} else {
+len += cnst.toString().length();
-/*
+break;
-If an argument is String, then we can call .length() on it. Sized/Exact modes have
+case TAG_ARG:
-converted arguments for us. If an argument is primitive, we can provide a guess
+/*
-for its String representation size.
+If an argument is String, then we can call .length() on it. Sized/Exact modes have
-*/
+converted arguments for us. If an argument is primitive, we can provide a guess
-Class<?> cl = arr[el.getArgPos()];
+for its String representation size.
-if (cl == String.class) {
+*/
-mv.visitIntInsn(ALOAD, off);
+Class<?> cl = arr[el.getArgPos()];
-mv.visitMethodInsn(
+if (cl == String.class) {
-INVOKEVIRTUAL,
+mv.visitIntInsn(ALOAD, off);
-"java/lang/String",
+mv.visitMethodInsn(
-"length",
+INVOKEVIRTUAL,
-"()I",
+"java/lang/String",
-false
+"length",
-);
+"()I",
-mv.visitInsn(IADD);
+false
-} else if (cl.isPrimitive()) {
+);
-len += estimateSize(cl);
+mv.visitInsn(IADD);
-}
+} else if (cl.isPrimitive()) {
-off += getParameterSize(cl);
+len += estimateSize(cl);
+}
+off += getParameterSize(cl);
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 }
 // Constants have non-zero length, mix in
 if (len > 0) {
 // At this point, we have a blank StringBuilder on stack, fill it in with .append calls.
 {
 int off = 0;
 for (RecipeElement el : recipe.getElements()) {
 String desc;
-if (el.isConst()) {
+switch (el.getTag()) {
-Object cnst = el.getValue();
+case TAG_CONST:
-mv.visitLdcInsn(cnst);
+Object cnst = el.getValue();
-desc = getSBAppendDesc(cnst.getClass());
+mv.visitLdcInsn(cnst);
-} else {
+desc = getSBAppendDesc(cnst.getClass());
-Class<?> cl = arr[el.getArgPos()];
+break;
-mv.visitVarInsn(getLoadOpcode(cl), off);
+case TAG_ARG:
-off += getParameterSize(cl);
+Class<?> cl = arr[el.getArgPos()];
-desc = getSBAppendDesc(cl);
+mv.visitVarInsn(getLoadOpcode(cl), off);
+off += getParameterSize(cl);
+desc = getSBAppendDesc(cl);
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 mv.visitMethodInsn(
 INVOKEVIRTUAL,
 "java/lang/StringBuilder",
 filters[i] = filter;
 ptypes[i] = filter.type().returnType();
 }
 }
-List<Class<?>> ptypesList = Arrays.asList(ptypes);
 MethodHandle[] lengthers = new MethodHandle[pc];
 // Figure out lengths: constants' lengths can be deduced on the spot.
 // All reference arguments were filtered to String in the combinators below, so we can
 // call the usual String.length(). Primitive values string sizes can be estimated.
 int initial = 0;
 for (RecipeElement el : recipe.getElements()) {
-if (el.isConst()) {
+switch (el.getTag()) {
-Object cnst = el.getValue();
+case TAG_CONST:
-initial += cnst.toString().length();
+Object cnst = el.getValue();
-} else {
+initial += cnst.toString().length();
-final int i = el.getArgPos();
+break;
-Class<?> type = ptypesList.get(i);
+case TAG_ARG:
-if (type.isPrimitive()) {
+final int i = el.getArgPos();
-MethodHandle est = MethodHandles.constant(int.class, estimateSize(type));
+Class<?> type = ptypes[i];
-est = MethodHandles.dropArguments(est, 0, type);
+if (type.isPrimitive()) {
-lengthers[i] = est;
+MethodHandle est = MethodHandles.constant(int.class, estimateSize(type));
-} else {
+est = MethodHandles.dropArguments(est, 0, type);
-lengthers[i] = STRING_LENGTH;
+lengthers[i] = est;
-}
+} else {
+lengthers[i] = STRING_LENGTH;
+}
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 }
 // Create (StringBuilder, <args>) shape for appending:
-MethodHandle builder = MethodHandles.dropArguments(MethodHandles.identity(StringBuilder.class), 1, ptypesList);
+MethodHandle builder = MethodHandles.dropArguments(MethodHandles.identity(StringBuilder.class), 1, ptypes);
 // Compose append calls. This is done in reverse because the application order is
 // reverse as well.
 List<RecipeElement> elements = recipe.getElements();
 for (int i = elements.size() - 1; i >= 0; i--) {
 RecipeElement el = elements.get(i);
 MethodHandle appender;
-if (el.isConst()) {
+switch (el.getTag()) {
-Object constant = el.getValue();
+case TAG_CONST:
-MethodHandle mh = appender(adaptToStringBuilder(constant.getClass()));
+Object constant = el.getValue();
-appender = MethodHandles.insertArguments(mh, 1, constant);
+MethodHandle mh = appender(adaptToStringBuilder(constant.getClass()));
-} else {
+appender = MethodHandles.insertArguments(mh, 1, constant);
-int ac = el.getArgPos();
+break;
-appender = appender(ptypesList.get(ac));
+case TAG_ARG:
+int ac = el.getArgPos();
-// Insert dummy arguments to match the prefix in the signature.
+appender = appender(ptypes[ac]);
-// The actual appender argument will be the ac-ith argument.
-if (ac != 0) {
+// Insert dummy arguments to match the prefix in the signature.
-appender = MethodHandles.dropArguments(appender, 1, ptypesList.subList(0, ac));
+// The actual appender argument will be the ac-ith argument.
-}
+if (ac != 0) {
+appender = MethodHandles.dropArguments(appender, 1, Arrays.copyOf(ptypes, ac));
+}
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 builder = MethodHandles.foldArguments(builder, appender);
 }
 // Build the sub-tree that adds the sizes and produces a StringBuilder:
 }
 filters[i] = filter;
 ptypes[i] = filter.type().returnType();
 }
 }
-List<Class<?>> ptypesList = Arrays.asList(ptypes);
 // Start building the combinator tree. The tree "starts" with (<parameters>)String, and "finishes"
 // with the (int, byte[], byte)String in String helper. The combinators are assembled bottom-up,
 // which makes the code arguably hard to read.
 // Mix in prependers. This happens when (int, byte[], byte) = (index, storage, coder) is already
 // known from the combinators below. We are assembling the string backwards, so "index" is the
 // *ending* index.
 for (RecipeElement el : recipe.getElements()) {
 MethodHandle prepender;
-if (el.isConst()) {
+switch (el.getTag()) {
-Object cnst = el.getValue();
+case TAG_CONST:
-prepender = MethodHandles.insertArguments(prepender(cnst.getClass()), 3, cnst);
+Object cnst = el.getValue();
-} else {
+prepender = MethodHandles.insertArguments(prepender(cnst.getClass()), 3, cnst);
-int pos = el.getArgPos();
+break;
-prepender = selectArgument(prepender(ptypesList.get(pos)), 3, ptypesList, pos);
+case TAG_ARG:
+int pos = el.getArgPos();
+prepender = selectArgument(prepender(ptypes[pos]), 3, ptypes, pos);
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 // Remove "old" index from arguments
 mh = MethodHandles.dropArguments(mh, 1, int.class);
 .changeParameterType(1, int.class);
 mh = MethodHandles.permuteArguments(mh, nmt, swap10(nmt.parameterCount()));
 }
 // Fold in byte[] instantiation at argument 0.
-MethodHandle combiner = MethodHandles.dropArguments(NEW_ARRAY, 2, ptypesList);
+MethodHandle combiner = MethodHandles.dropArguments(NEW_ARRAY, 2, ptypes);
 mh = MethodHandles.foldArguments(mh, combiner);
 // Start combining length and coder mixers.
 //
 // Length is easy: constant lengths can be computed on the spot, and all non-constant
 // The method handle shape after all length and coder mixers is:
 //   (int, byte, <args>)String = ("index", "coder", <args>)
 byte initialCoder = INITIAL_CODER;
 int initialLen = 0;    // initial length, in characters
 for (RecipeElement el : recipe.getElements()) {
-if (el.isConst()) {
+switch (el.getTag()) {
-Object constant = el.getValue();
+case TAG_CONST:
-String s = constant.toString();
+Object constant = el.getValue();
-initialCoder = (byte) coderMixer(String.class).invoke(initialCoder, s);
+String s = constant.toString();
-initialLen += s.length();
+initialCoder = (byte) coderMixer(String.class).invoke(initialCoder, s);
-} else {
+initialLen += s.length();
-int ac = el.getArgPos();
+break;
+case TAG_ARG:
-Class<?> argClass = ptypesList.get(ac);
+int ac = el.getArgPos();
-MethodHandle lm = selectArgument(lengthMixer(argClass), 1, ptypesList, ac);
-lm = MethodHandles.dropArguments(lm, 0, byte.class); // (*)
+Class<?> argClass = ptypes[ac];
-lm = MethodHandles.dropArguments(lm, 2, byte.class);
+MethodHandle lm = selectArgument(lengthMixer(argClass), 1, ptypes, ac);
+lm = MethodHandles.dropArguments(lm, 0, byte.class); // (*)
-MethodHandle cm = selectArgument(coderMixer(argClass),  1, ptypesList, ac);
+lm = MethodHandles.dropArguments(lm, 2, byte.class);
-cm = MethodHandles.dropArguments(cm, 0, int.class);  // (**)
+MethodHandle cm = selectArgument(coderMixer(argClass),  1, ptypes, ac);
-// Read this bottom up:
+cm = MethodHandles.dropArguments(cm, 0, int.class);  // (**)
-// 4. Drop old index and coder, producing ("new-index", "new-coder", <args>)
+// Read this bottom up:
-mh = MethodHandles.dropArguments(mh, 2, int.class, byte.class);
+// 4. Drop old index and coder, producing ("new-index", "new-coder", <args>)
-// 3. Compute "new-index", producing ("new-index", "new-coder", "old-index", "old-coder", <args>)
+mh = MethodHandles.dropArguments(mh, 2, int.class, byte.class);
-//    Length mixer ignores both "new-coder" and "old-coder" due to dropArguments above (*)
-mh = MethodHandles.foldArguments(mh, lm);
+// 3. Compute "new-index", producing ("new-index", "new-coder", "old-index", "old-coder", <args>)
+//    Length mixer ignores both "new-coder" and "old-coder" due to dropArguments above (*)
-// 2. Compute "new-coder", producing ("new-coder", "old-index", "old-coder", <args>)
+mh = MethodHandles.foldArguments(mh, lm);
-//    Coder mixer ignores the "old-index" arg due to dropArguments above (**)
-mh = MethodHandles.foldArguments(mh, cm);
+// 2. Compute "new-coder", producing ("new-coder", "old-index", "old-coder", <args>)
+//    Coder mixer ignores the "old-index" arg due to dropArguments above (**)
-// 1. The mh shape here is ("old-index", "old-coder", <args>)
+mh = MethodHandles.foldArguments(mh, cm);
+// 1. The mh shape here is ("old-index", "old-coder", <args>)
+break;
+default:
+throw new StringConcatException("Unhandled tag: " + el.getTag());
 }
 }
 // Insert initial lengths and coders here.
 // The method handle shape here is (<args>).
 }
 return perm;
 }
 // Adapts: (...prefix..., parameter[pos])R -> (...prefix..., ...parameters...)R
-private static MethodHandle selectArgument(MethodHandle mh, int prefix, List<Class<?>> ptypes, int pos) {
+private static MethodHandle selectArgument(MethodHandle mh, int prefix, Class<?>[] ptypes, int pos) {
 if (pos == 0) {
-return MethodHandles.dropArguments(mh, prefix + 1, ptypes.subList(1, ptypes.size()));
+return MethodHandles.dropArguments(mh, prefix + 1, Arrays.copyOfRange(ptypes, 1, ptypes.length));
-} else if (pos == ptypes.size() - 1) {
+} else if (pos == ptypes.length - 1) {
-return MethodHandles.dropArguments(mh, prefix, ptypes.subList(0, ptypes.size() - 1));
+return MethodHandles.dropArguments(mh, prefix, Arrays.copyOf(ptypes, ptypes.length - 1));
 } else { // 0 < pos < ptypes.size() - 1
-MethodHandle t = MethodHandles.dropArguments(mh, prefix, ptypes.subList(0, pos));
+MethodHandle t = MethodHandles.dropArguments(mh, prefix, Arrays.copyOf(ptypes, pos));
-return MethodHandles.dropArguments(t, prefix + 1 + pos, ptypes.subList(pos + 1, ptypes.size()));
+return MethodHandles.dropArguments(t, prefix + 1 + pos, Arrays.copyOfRange(ptypes, pos + 1, ptypes.length));
 }
 }
 @ForceInline
 private static byte[] newArray(int length, byte coder) {
 private static final MethodHandle CHECK_INDEX;
 private static final MethodHandle NEW_ARRAY;
 private static final ConcurrentMap<Class<?>, MethodHandle> PREPENDERS;
 private static final ConcurrentMap<Class<?>, MethodHandle> LENGTH_MIXERS;
 private static final ConcurrentMap<Class<?>, MethodHandle> CODER_MIXERS;
-private static final Class<?> STRING_HELPER;
 private static final byte INITIAL_CODER;
+static final Class<?> STRING_HELPER;
 static {
 try {
 STRING_HELPER = Class.forName("java.lang.StringConcatHelper");
 MethodHandle initCoder = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "initialCoder", byte.class);
 }
 }
 /* ------------------------------- Common utilities ------------------------------------ */
-private static MethodHandle lookupStatic(Lookup lookup, Class<?> refc, String name, Class<?> rtype, Class<?>... ptypes) {
+static MethodHandle lookupStatic(Lookup lookup, Class<?> refc, String name, Class<?> rtype, Class<?>... ptypes) {
 try {
 return lookup.findStatic(refc, name, MethodType.methodType(rtype, ptypes));
 } catch (NoSuchMethodException | IllegalAccessException e) {
 throw new AssertionError(e);
 }
 }
-private static MethodHandle lookupVirtual(Lookup lookup, Class<?> refc, String name, Class<?> rtype, Class<?>... ptypes) {
+static MethodHandle lookupVirtual(Lookup lookup, Class<?> refc, String name, Class<?> rtype, Class<?>... ptypes) {
 try {
 return lookup.findVirtual(refc, name, MethodType.methodType(rtype, ptypes));
 } catch (NoSuchMethodException | IllegalAccessException e) {
 throw new AssertionError(e);
 }
 }
-private static MethodHandle lookupConstructor(Lookup lookup, Class<?> refc, Class<?> ptypes) {
+static MethodHandle lookupConstructor(Lookup lookup, Class<?> refc, Class<?> ptypes) {
 try {
 return lookup.findConstructor(refc, MethodType.methodType(void.class, ptypes));
 } catch (NoSuchMethodException | IllegalAccessException e) {
 throw new AssertionError(e);
 }
 }
-private static int estimateSize(Class<?> cl) {
+static int estimateSize(Class<?> cl) {
 if (cl == Integer.TYPE) {
 return 11; // "-2147483648"
 } else if (cl == Boolean.TYPE) {
 return 5; // "false"
 } else if (cl == Byte.TYPE) {
 } else {
 throw new IllegalArgumentException("Cannot estimate the size for " + cl);
 }
 }
-private static Class<?> adaptToStringBuilder(Class<?> c) {
+static Class<?> adaptToStringBuilder(Class<?> c) {
 if (c.isPrimitive()) {
 if (c == Byte.TYPE || c == Short.TYPE) {
 return int.class;
 }
 } else {

changeset 40272	6af4511ee5a4
parent 40256	c5e03eaf7ba2
child 40810	b88d5910ea1e