1 /*
2 * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2024, Alibaba Group Holding Limited. All Rights Reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation. Oracle designates this
9 * particular file as subject to the "Classpath" exception as provided
10 * by Oracle in the LICENSE file that accompanied this code.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23 * or visit www.oracle.com if you need additional information or have any
24 * questions.
25 */
26
27 package java.lang.invoke;
28
29 import jdk.internal.access.JavaLangAccess;
30 import jdk.internal.access.SharedSecrets;
31 import jdk.internal.constant.ConstantUtils;
32 import jdk.internal.constant.MethodTypeDescImpl;
33 import jdk.internal.constant.ReferenceClassDescImpl;
34 import jdk.internal.misc.VM;
35 import jdk.internal.util.ClassFileDumper;
36 import jdk.internal.util.ReferenceKey;
37 import jdk.internal.util.ReferencedKeyMap;
38 import jdk.internal.vm.annotation.Stable;
39 import sun.invoke.util.Wrapper;
40
41 import java.lang.classfile.Annotation;
42 import java.lang.classfile.ClassBuilder;
43 import java.lang.classfile.ClassFile;
44 import java.lang.classfile.CodeBuilder;
45 import java.lang.classfile.MethodBuilder;
46 import java.lang.classfile.TypeKind;
47 import java.lang.classfile.attribute.RuntimeVisibleAnnotationsAttribute;
48 import java.lang.constant.ClassDesc;
49 import java.lang.constant.MethodTypeDesc;
50 import java.lang.invoke.MethodHandles.Lookup;
51 import java.lang.ref.SoftReference;
52 import java.util.Map;
53 import java.util.Objects;
54 import java.util.concurrent.ConcurrentHashMap;
55 import java.util.function.Consumer;
56 import java.util.function.Supplier;
57
58 import static java.lang.classfile.ClassFile.*;
59 import static java.lang.constant.ConstantDescs.*;
60 import static java.lang.invoke.MethodType.methodType;
61
62 /**
63 * <p>Methods to facilitate the creation of String concatenation methods, that
64 * can be used to efficiently concatenate a known number of arguments of known
65 * types, possibly after type adaptation and partial evaluation of arguments.
66 * These methods are typically used as <em>bootstrap methods</em> for {@code
67 * invokedynamic} call sites, to support the <em>string concatenation</em>
68 * feature of the Java Programming Language.
69 *
70 * <p>Indirect access to the behavior specified by the provided {@code
71 * MethodHandle} proceeds in order through two phases:
72 *
73 * <ol>
74 * <li><em>Linkage</em> occurs when the methods in this class are invoked.
75 * They take as arguments a method type describing the concatenated arguments
76 * count and types, and optionally the String <em>recipe</em>, plus the
77 * constants that participate in the String concatenation. The details on
78 * accepted recipe shapes are described further below. Linkage may involve
79 * dynamically loading a new class that implements the expected concatenation
80 * behavior. The {@code CallSite} holds the {@code MethodHandle} pointing to the
81 * exact concatenation method. The concatenation methods may be shared among
82 * different {@code CallSite}s, e.g. if linkage methods produce them as pure
83 * functions.</li>
84 *
85 * <li><em>Invocation</em> occurs when a generated concatenation method is
86 * invoked with the exact dynamic arguments. This may occur many times for a
87 * single concatenation method. The method referenced by the behavior {@code
88 * MethodHandle} is invoked with the static arguments and any additional dynamic
89 * arguments provided on invocation, as if by {@link MethodHandle#invoke(Object...)}.</li>
90 * </ol>
91 *
92 * <p> This class provides two forms of linkage methods: a simple version
93 * ({@link #makeConcat(java.lang.invoke.MethodHandles.Lookup, String,
94 * MethodType)}) using only the dynamic arguments, and an advanced version
95 * ({@link #makeConcatWithConstants(java.lang.invoke.MethodHandles.Lookup,
96 * String, MethodType, String, Object...)} using the advanced forms of capturing
97 * the constant arguments. The advanced strategy can produce marginally better
98 * invocation bytecode, at the expense of exploding the number of shapes of
99 * string concatenation methods present at runtime, because those shapes would
100 * include constant static arguments as well.
101 *
102 * @author Aleksey Shipilev
103 * @author Remi Forax
104 * @author Peter Levart
105 *
106 * @apiNote
107 * <p>There is a JVM limit (classfile structural constraint): no method
108 * can call with more than 255 slots. This limits the number of static and
109 * dynamic arguments one can pass to bootstrap method. Since there are potential
110 * concatenation strategies that use {@code MethodHandle} combinators, we need
111 * to reserve a few empty slots on the parameter lists to capture the
112 * temporal results. This is why bootstrap methods in this factory do not accept
113 * more than 200 argument slots. Users requiring more than 200 argument slots in
114 * concatenation are expected to split the large concatenation in smaller
115 * expressions.
116 *
117 * @since 9
118 */
119 public final class StringConcatFactory {
120 private static final int HIGH_ARITY_THRESHOLD;
121 private static final int CACHE_THRESHOLD;
122 private static final int FORCE_INLINE_THRESHOLD;
123
124 static {
125 String highArity = VM.getSavedProperty("java.lang.invoke.StringConcat.highArityThreshold");
126 HIGH_ARITY_THRESHOLD = highArity != null ? Integer.parseInt(highArity) : 0;
127
128 String cacheThreshold = VM.getSavedProperty("java.lang.invoke.StringConcat.cacheThreshold");
129 CACHE_THRESHOLD = cacheThreshold != null ? Integer.parseInt(cacheThreshold) : 256;
130
131 String inlineThreshold = VM.getSavedProperty("java.lang.invoke.StringConcat.inlineThreshold");
132 FORCE_INLINE_THRESHOLD = inlineThreshold != null ? Integer.parseInt(inlineThreshold) : 16;
133 }
134
135 /**
136 * Tag used to demarcate an ordinary argument.
137 */
138 private static final char TAG_ARG = '\u0001';
139
140 /**
141 * Tag used to demarcate a constant.
142 */
143 private static final char TAG_CONST = '\u0002';
144
145 /**
146 * Maximum number of argument slots in String Concat call.
147 *
148 * While the maximum number of argument slots that indy call can handle is 253,
149 * we do not use all those slots, to let the strategies with MethodHandle
150 * combinators to use some arguments.
151 */
152 private static final int MAX_INDY_CONCAT_ARG_SLOTS = 200;
153
154 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
155
156 // StringConcatFactory bootstrap methods are startup sensitive, and may be
157 // special cased in java.lang.invoke.BootstrapMethodInvoker to ensure
158 // methods are invoked with exact type information to avoid generating
159 // code for runtime checks. Take care any changes or additions here are
160 // reflected there as appropriate.
161
162 /**
163 * Facilitates the creation of optimized String concatenation methods, that
164 * can be used to efficiently concatenate a known number of arguments of
165 * known types, possibly after type adaptation and partial evaluation of
166 * arguments. Typically used as a <em>bootstrap method</em> for {@code
167 * invokedynamic} call sites, to support the <em>string concatenation</em>
168 * feature of the Java Programming Language.
169 *
170 * <p>When the target of the {@code CallSite} returned from this method is
171 * invoked, it returns the result of String concatenation, taking all
172 * function arguments passed to the linkage method as inputs for
173 * concatenation. The target signature is given by {@code concatType}.
174 * For a target accepting:
175 * <ul>
176 * <li>zero inputs, concatenation results in an empty string;</li>
177 * <li>one input, concatenation results in the single
178 * input converted as per JLS {@jls 5.1.11} "String Conversion"; otherwise</li>
179 * <li>two or more inputs, the inputs are concatenated as per
180 * requirements stated in JLS {@jls 15.18.1} "String Concatenation Operator +".
181 * The inputs are converted as per JLS {@jls 5.1.11} "String Conversion",
182 * and combined from left to right.</li>
183 * </ul>
184 *
185 * <p>Assume the linkage arguments are as follows:
186 *
187 * <ul>
188 * <li>{@code concatType}, describing the {@code CallSite} signature</li>
189 * </ul>
190 *
191 * <p>Then the following linkage invariants must hold:
192 *
193 * <ul>
194 * <li>The number of parameter slots in {@code concatType} is
195 * less than or equal to 200</li>
196 * <li>The return type in {@code concatType} is assignable from {@link java.lang.String}</li>
197 * </ul>
198 *
199 * @param lookup Represents a lookup context with the accessibility
200 * privileges of the caller. Specifically, the lookup
201 * context must have
202 * {@linkplain MethodHandles.Lookup#hasFullPrivilegeAccess()
203 * full privilege access}.
204 * When used with {@code invokedynamic}, this is stacked
205 * automatically by the VM.
206 * @param name The name of the method to implement. This name is
207 * arbitrary, and has no meaning for this linkage method.
208 * When used with {@code invokedynamic}, this is provided by
209 * the {@code NameAndType} of the {@code InvokeDynamic}
210 * structure and is stacked automatically by the VM.
211 * @param concatType The expected signature of the {@code CallSite}. The
212 * parameter types represent the types of concatenation
213 * arguments; the return type is always assignable from {@link
214 * java.lang.String}. When used with {@code invokedynamic},
215 * this is provided by the {@code NameAndType} of the {@code
216 * InvokeDynamic} structure and is stacked automatically by
217 * the VM.
218 * @return a CallSite whose target can be used to perform String
219 * concatenation, with dynamic concatenation arguments described by the given
220 * {@code concatType}.
221 * @throws StringConcatException If any of the linkage invariants described
222 * here are violated, or the lookup context
223 * does not have private access privileges.
224 * @throws NullPointerException If any of the incoming arguments is null.
225 * This will never happen when a bootstrap method
226 * is called with invokedynamic.
227 *
228 * @jls 5.1.11 String Conversion
229 * @jls 15.18.1 String Concatenation Operator +
230 */
231 public static CallSite makeConcat(MethodHandles.Lookup lookup,
232 String name,
233 MethodType concatType) throws StringConcatException {
234 // This bootstrap method is unlikely to be used in practice,
235 // avoid optimizing it at the expense of makeConcatWithConstants
236
237 // Mock the recipe to reuse the concat generator code
238 String recipe = "\u0001".repeat(concatType.parameterCount());
239 return makeConcatWithConstants(lookup, name, concatType, recipe);
240 }
241
242 /**
243 * Facilitates the creation of optimized String concatenation methods, that
244 * can be used to efficiently concatenate a known number of arguments of
245 * known types, possibly after type adaptation and partial evaluation of
246 * arguments. Typically used as a <em>bootstrap method</em> for {@code
247 * invokedynamic} call sites, to support the <em>string concatenation</em>
248 * feature of the Java Programming Language.
249 *
250 * <p>When the target of the {@code CallSite} returned from this method is
251 * invoked, it returns the result of String concatenation, taking all
252 * function arguments and constants passed to the linkage method as inputs for
253 * concatenation. The target signature is given by {@code concatType}, and
254 * does not include constants.
255 * For a target accepting:
256 * <ul>
257 * <li>zero inputs, concatenation results in an empty string;</li>
258 * <li>one input, concatenation results in the single
259 * input converted as per JLS {@jls 5.1.11} "String Conversion"; otherwise</li>
260 * <li>two or more inputs, the inputs are concatenated as per
261 * requirements stated in JLS {@jls 15.18.1} "String Concatenation Operator +".
262 * The inputs are converted as per JLS {@jls 5.1.11} "String Conversion",
263 * and combined from left to right.</li>
264 * </ul>
265 *
266 * <p>The concatenation <em>recipe</em> is a String description for the way to
267 * construct a concatenated String from the arguments and constants. The
268 * recipe is processed from left to right, and each character represents an
269 * input to concatenation. Recipe characters mean:
270 *
271 * <ul>
272 *
273 * <li><em>\1 (Unicode point 0001)</em>: an ordinary argument. This
274 * input is passed through dynamic argument, and is provided during the
275 * concatenation method invocation. This input can be null.</li>
276 *
277 * <li><em>\2 (Unicode point 0002):</em> a constant. This input passed
278 * through static bootstrap argument. This constant can be any value
279 * representable in constant pool. If necessary, the factory would call
280 * {@code toString} to perform a one-time String conversion.</li>
281 *
282 * <li><em>Any other char value:</em> a single character constant.</li>
283 * </ul>
284 *
285 * <p>Assume the linkage arguments are as follows:
286 *
287 * <ul>
288 * <li>{@code concatType}, describing the {@code CallSite} signature</li>
289 * <li>{@code recipe}, describing the String recipe</li>
290 * <li>{@code constants}, the vararg array of constants</li>
291 * </ul>
292 *
293 * <p>Then the following linkage invariants must hold:
294 *
295 * <ul>
296 * <li>The number of parameter slots in {@code concatType} is less than
297 * or equal to 200</li>
298 *
299 * <li>The parameter count in {@code concatType} is equal to number of \1 tags
300 * in {@code recipe}</li>
301 *
302 * <li>The return type in {@code concatType} is assignable
303 * from {@link java.lang.String}, and matches the return type of the
304 * returned {@link MethodHandle}</li>
305 *
306 * <li>The number of elements in {@code constants} is equal to number of \2
307 * tags in {@code recipe}</li>
308 * </ul>
309 *
310 * @param lookup Represents a lookup context with the accessibility
311 * privileges of the caller. Specifically, the lookup
312 * context must have
313 * {@linkplain MethodHandles.Lookup#hasFullPrivilegeAccess()
314 * full privilege access}.
315 * When used with {@code invokedynamic}, this is stacked
316 * automatically by the VM.
317 * @param name The name of the method to implement. This name is
318 * arbitrary, and has no meaning for this linkage method.
319 * When used with {@code invokedynamic}, this is provided
320 * by the {@code NameAndType} of the {@code InvokeDynamic}
321 * structure and is stacked automatically by the VM.
322 * @param concatType The expected signature of the {@code CallSite}. The
323 * parameter types represent the types of dynamic concatenation
324 * arguments; the return type is always assignable from {@link
325 * java.lang.String}. When used with {@code
326 * invokedynamic}, this is provided by the {@code
327 * NameAndType} of the {@code InvokeDynamic} structure and
328 * is stacked automatically by the VM.
329 * @param recipe Concatenation recipe, described above.
330 * @param constants A vararg parameter representing the constants passed to
331 * the linkage method.
332 * @return a CallSite whose target can be used to perform String
333 * concatenation, with dynamic concatenation arguments described by the given
334 * {@code concatType}.
335 * @throws StringConcatException If any of the linkage invariants described
336 * here are violated, or the lookup context
337 * does not have private access privileges.
338 * @throws NullPointerException If any of the incoming arguments is null, or
339 * any constant in {@code recipe} is null.
340 * This will never happen when a bootstrap method
341 * is called with invokedynamic.
342 * @apiNote Code generators have three distinct ways to process a constant
343 * string operand S in a string concatenation expression. First, S can be
344 * materialized as a reference (using ldc) and passed as an ordinary argument
345 * (recipe '\1'). Or, S can be stored in the constant pool and passed as a
346 * constant (recipe '\2') . Finally, if S contains neither of the recipe
347 * tag characters ('\1', '\2') then S can be interpolated into the recipe
348 * itself, causing its characters to be inserted into the result.
349 *
350 * @jls 5.1.11 String Conversion
351 * @jls 15.18.1 String Concatenation Operator +
352 */
353 public static CallSite makeConcatWithConstants(MethodHandles.Lookup lookup,
354 String name,
355 MethodType concatType,
356 String recipe,
357 Object... constants)
358 throws StringConcatException
359 {
360 Objects.requireNonNull(lookup, "Lookup is null");
361 Objects.requireNonNull(name, "Name is null");
362 Objects.requireNonNull(recipe, "Recipe is null");
363 Objects.requireNonNull(concatType, "Concat type is null");
364 Objects.requireNonNull(constants, "Constants are null");
365
366 for (Object o : constants) {
367 Objects.requireNonNull(o, "Cannot accept null constants");
368 }
369
370 if ((lookup.lookupModes() & MethodHandles.Lookup.PRIVATE) == 0) {
371 throw new StringConcatException("Invalid caller: " +
372 lookup.lookupClass().getName());
373 }
374
375 String[] constantStrings = parseRecipe(concatType, recipe, constants);
376
377 if (!concatType.returnType().isAssignableFrom(String.class)) {
378 throw new StringConcatException(
379 "The return type should be compatible with String, but it is " +
380 concatType.returnType());
381 }
382
383 if (concatType.parameterSlotCount() > MAX_INDY_CONCAT_ARG_SLOTS) {
384 throw new StringConcatException("Too many concat argument slots: " +
385 concatType.parameterSlotCount() +
386 ", can only accept " +
387 MAX_INDY_CONCAT_ARG_SLOTS);
388 }
389
390 try {
391 MethodHandle mh = makeSimpleConcat(concatType, constantStrings);
392 if (mh == null && concatType.parameterCount() <= HIGH_ARITY_THRESHOLD) {
393 mh = generateMHInlineCopy(concatType, constantStrings);
394 }
395
396 if (mh == null) {
397 mh = InlineHiddenClassStrategy.generate(lookup, concatType, constantStrings);
398 }
399 mh = mh.viewAsType(concatType, true);
400
401 return new ConstantCallSite(mh);
402 } catch (Error e) {
403 // Pass through any error
404 throw e;
405 } catch (Throwable t) {
406 throw new StringConcatException("Generator failed", t);
407 }
408 }
409
410 private static String[] parseRecipe(MethodType concatType,
411 String recipe,
412 Object[] constants)
413 throws StringConcatException
414 {
415
416 Objects.requireNonNull(recipe, "Recipe is null");
417 int paramCount = concatType.parameterCount();
418 // Array containing interleaving String constants, starting with
419 // the first prefix and ending with the final prefix:
420 //
421 // consts[0] + arg0 + consts[1] + arg 1 + ... + consts[paramCount].
422 //
423 // consts will be null if there's no constant to insert at a position.
424 // An empty String constant will be replaced by null.
425 String[] consts = new String[paramCount + 1];
426
427 int cCount = 0;
428 int oCount = 0;
429
430 StringBuilder acc = new StringBuilder();
431
432 for (int i = 0; i < recipe.length(); i++) {
433 char c = recipe.charAt(i);
434
435 if (c == TAG_CONST) {
436 if (cCount == constants.length) {
437 // Not enough constants
438 throw constantMismatch(constants, cCount);
439 }
440 // Accumulate constant args along with any constants encoded
441 // into the recipe
442 acc.append(constants[cCount++]);
443 } else if (c == TAG_ARG) {
444 // Check for overflow
445 if (oCount >= paramCount) {
446 throw argumentMismatch(concatType, oCount);
447 }
448
449 // Flush any accumulated characters into a constant
450 consts[oCount++] = acc.length() > 0 ? acc.toString() : "";
451 acc.setLength(0);
452 } else {
453 // Not a special character, this is a constant embedded into
454 // the recipe itself.
455 acc.append(c);
456 }
457 }
458 if (oCount != concatType.parameterCount()) {
459 throw argumentMismatch(concatType, oCount);
460 }
461 if (cCount < constants.length) {
462 throw constantMismatch(constants, cCount);
463 }
464
465 // Flush the remaining characters as constant:
466 consts[oCount] = acc.length() > 0 ? acc.toString() : "";
467 return consts;
468 }
469
470 private static StringConcatException argumentMismatch(MethodType concatType,
471 int oCount) {
472 return new StringConcatException(
473 "Mismatched number of concat arguments: recipe wants " +
474 oCount +
475 " arguments, but signature provides " +
476 concatType.parameterCount());
477 }
478
479 private static StringConcatException constantMismatch(Object[] constants,
480 int cCount) {
481 return new StringConcatException(
482 "Mismatched number of concat constants: recipe wants " +
483 cCount +
484 " constants, but only " +
485 constants.length +
486 " are passed");
487 }
488
489 private static MethodHandle makeSimpleConcat(MethodType mt, String[] constants) {
490 int paramCount = mt.parameterCount();
491 String suffix = constants[paramCount];
492
493 // Fast-path trivial concatenations
494 if (paramCount == 0) {
495 return MethodHandles.insertArguments(newStringifier(), 0, suffix == null ? "" : suffix);
496 }
497 if (paramCount == 1) {
498 String prefix = constants[0];
499 // Empty constants will be
500 if (prefix.isEmpty()) {
501 if (suffix.isEmpty()) {
502 return unaryConcat(mt.parameterType(0));
503 } else if (!mt.hasPrimitives()) {
504 return MethodHandles.insertArguments(simpleConcat(), 1, suffix);
505 } // else fall-through
506 } else if (suffix.isEmpty() && !mt.hasPrimitives()) {
507 // Non-primitive argument
508 return MethodHandles.insertArguments(simpleConcat(), 0, prefix);
509 } // fall-through if there's both a prefix and suffix
510 } else if (paramCount == 2 && !mt.hasPrimitives() && suffix.isEmpty()
511 && constants[0].isEmpty() && constants[1].isEmpty()) {
512 // Two reference arguments, no surrounding constants
513 return simpleConcat();
514 }
515
516 return null;
517 }
518
519 /**
520 * <p>This strategy replicates what StringBuilders are doing: it builds the
521 * byte[] array on its own and passes that byte[] array to String
522 * constructor. This strategy requires access to some private APIs in JDK,
523 * most notably, the private String constructor that accepts byte[] arrays
524 * without copying.
525 */
526 private static MethodHandle generateMHInlineCopy(MethodType mt, String[] constants) {
527 int paramCount = mt.parameterCount();
528 String suffix = constants[paramCount];
529
530
531 // else... fall-through to slow-path
532
533 // Create filters and obtain filtered parameter types. Filters would be used in the beginning
534 // to convert the incoming arguments into the arguments we can process (e.g. Objects -> Strings).
535 // The filtered argument type list is used all over in the combinators below.
536
537 Class<?>[] ptypes = mt.erase().parameterArray();
538 MethodHandle[] objFilters = null;
539 MethodHandle[] floatFilters = null;
540 MethodHandle[] doubleFilters = null;
541 for (int i = 0; i < ptypes.length; i++) {
542 Class<?> cl = ptypes[i];
543 // Use int as the logical type for subword integral types
544 // (byte and short). char and boolean require special
545 // handling so don't change the logical type of those
546 ptypes[i] = promoteToIntType(ptypes[i]);
547 // Object, float and double will be eagerly transformed
548 // into a (non-null) String as a first step after invocation.
549 // Set up to use String as the logical type for such arguments
550 // internally.
551 if (cl == Object.class) {
552 if (objFilters == null) {
553 objFilters = new MethodHandle[ptypes.length];
554 }
555 objFilters[i] = objectStringifier();
556 ptypes[i] = String.class;
557 } else if (cl == float.class) {
558 if (floatFilters == null) {
559 floatFilters = new MethodHandle[ptypes.length];
560 }
561 floatFilters[i] = floatStringifier();
562 ptypes[i] = String.class;
563 } else if (cl == double.class) {
564 if (doubleFilters == null) {
565 doubleFilters = new MethodHandle[ptypes.length];
566 }
567 doubleFilters[i] = doubleStringifier();
568 ptypes[i] = String.class;
569 }
570 }
571
572 // Start building the combinator tree. The tree "starts" with (<parameters>)String, and "finishes"
573 // with the (byte[], long)String shape to invoke newString in StringConcatHelper. The combinators are
574 // assembled bottom-up, which makes the code arguably hard to read.
575
576 // Drop all remaining parameter types, leave only helper arguments:
577 MethodHandle mh = MethodHandles.dropArgumentsTrusted(newString(), 2, ptypes);
578
579 // Calculate the initialLengthCoder value by looking at all constant values and summing up
580 // their lengths and adjusting the encoded coder bit if needed
581 long initialLengthCoder = INITIAL_CODER;
582
583 for (String constant : constants) {
584 if (constant != null) {
585 initialLengthCoder = JLA.stringConcatMix(initialLengthCoder, constant);
586 }
587 }
588
589 // Mix in prependers. This happens when (byte[], long) = (storage, indexCoder) is already
590 // known from the combinators below. We are assembling the string backwards, so the index coded
591 // into indexCoder is the *ending* index.
592 mh = filterInPrependers(mh, constants, ptypes);
593
594 // Fold in byte[] instantiation at argument 0
595 MethodHandle newArrayCombinator;
596 if (suffix == null || suffix.isEmpty()) {
597 suffix = "";
598 }
599 // newArray variant that deals with prepending any trailing constant
600 //
601 // initialLengthCoder is adjusted to have the correct coder
602 // and length: The newArrayWithSuffix method expects only the coder of the
603 // suffix to be encoded into indexCoder
604 initialLengthCoder -= suffix.length();
605 newArrayCombinator = newArrayWithSuffix(suffix);
606
607 mh = MethodHandles.foldArgumentsWithCombiner(mh, 0, newArrayCombinator,
608 1 // index
609 );
610
611 // Start combining length and coder mixers.
612 //
613 // Length is easy: constant lengths can be computed on the spot, and all non-constant
614 // shapes have been either converted to Strings, or explicit methods for getting the
615 // string length out of primitives are provided.
616 //
617 // Coders are more interesting. Only Object, String and char arguments (and constants)
618 // can have non-Latin1 encoding. It is easier to blindly convert constants to String,
619 // and deduce the coder from there. Arguments would be either converted to Strings
620 // during the initial filtering, or handled by specializations in MIXERS.
621 //
622 // The method handle shape before all mixers are combined in is:
623 // (long, <args>)String = ("indexCoder", <args>)
624 //
625 // We will bind the initialLengthCoder value to the last mixer (the one that will be
626 // executed first), then fold that in. This leaves the shape after all mixers are
627 // combined in as:
628 // (<args>)String = (<args>)
629
630 mh = filterAndFoldInMixers(mh, initialLengthCoder, ptypes);
631
632 // The method handle shape here is (<args>).
633
634 // Apply filters, converting the arguments:
635 if (objFilters != null) {
636 mh = MethodHandles.filterArguments(mh, 0, objFilters);
637 }
638 if (floatFilters != null) {
639 mh = MethodHandles.filterArguments(mh, 0, floatFilters);
640 }
641 if (doubleFilters != null) {
642 mh = MethodHandles.filterArguments(mh, 0, doubleFilters);
643 }
644
645 return mh;
646 }
647
648 // We need one prepender per argument, but also need to fold in constants. We do so by greedily
649 // creating prependers that fold in surrounding constants into the argument prepender. This reduces
650 // the number of unique MH combinator tree shapes we'll create in an application.
651 // Additionally we do this in chunks to reduce the number of combinators bound to the root tree,
652 // which simplifies the shape and makes construction of similar trees use less unique LF classes
653 private static MethodHandle filterInPrependers(MethodHandle mh, String[] constants, Class<?>[] ptypes) {
654 int pos;
655 int[] argPositions = null;
656 MethodHandle prepend;
657 for (pos = 0; pos < ptypes.length - 3; pos += 4) {
658 prepend = prepender(pos, constants, ptypes, 4);
659 argPositions = filterPrependArgPositions(argPositions, pos, 4);
660 mh = MethodHandles.filterArgumentsWithCombiner(mh, 1, prepend, argPositions);
661 }
662 if (pos < ptypes.length) {
663 int count = ptypes.length - pos;
664 prepend = prepender(pos, constants, ptypes, count);
665 argPositions = filterPrependArgPositions(argPositions, pos, count);
666 mh = MethodHandles.filterArgumentsWithCombiner(mh, 1, prepend, argPositions);
667 }
668 return mh;
669 }
670
671 static int[] filterPrependArgPositions(int[] argPositions, int pos, int count) {
672 if (argPositions == null || argPositions.length != count + 2) {
673 argPositions = new int[count + 2];
674 argPositions[0] = 1; // indexCoder
675 argPositions[1] = 0; // storage
676 }
677 int limit = count + 2;
678 for (int i = 2; i < limit; i++) {
679 argPositions[i] = i + pos;
680 }
681 return argPositions;
682 }
683
684
685 // We need one mixer per argument.
686 private static MethodHandle filterAndFoldInMixers(MethodHandle mh, long initialLengthCoder, Class<?>[] ptypes) {
687 int pos;
688 int[] argPositions = null;
689 for (pos = 0; pos < ptypes.length - 4; pos += 4) {
690 // Compute new "index" in-place pairwise using old value plus the appropriate arguments.
691 MethodHandle mix = mixer(ptypes[pos], ptypes[pos + 1], ptypes[pos + 2], ptypes[pos + 3]);
692 argPositions = filterMixerArgPositions(argPositions, pos, 4);
693 mh = MethodHandles.filterArgumentsWithCombiner(mh, 0,
694 mix, argPositions);
695 }
696
697 if (pos < ptypes.length) {
698 // Mix in the last 1 to 4 parameters, insert the initialLengthCoder into the final mixer and
699 // fold the result into the main combinator
700 mh = foldInLastMixers(mh, initialLengthCoder, pos, ptypes, ptypes.length - pos);
701 } else if (ptypes.length == 0) {
702 // No mixer (constants only concat), insert initialLengthCoder directly
703 mh = MethodHandles.insertArguments(mh, 0, initialLengthCoder);
704 }
705 return mh;
706 }
707
708 static int[] filterMixerArgPositions(int[] argPositions, int pos, int count) {
709 if (argPositions == null || argPositions.length != count + 2) {
710 argPositions = new int[count + 1];
711 argPositions[0] = 0; // indexCoder
712 }
713 int limit = count + 1;
714 for (int i = 1; i < limit; i++) {
715 argPositions[i] = i + pos;
716 }
717 return argPositions;
718 }
719
720 private static MethodHandle foldInLastMixers(MethodHandle mh, long initialLengthCoder, int pos, Class<?>[] ptypes, int count) {
721 MethodHandle mix = switch (count) {
722 case 1 -> mixer(ptypes[pos]);
723 case 2 -> mixer(ptypes[pos], ptypes[pos + 1]);
724 case 3 -> mixer(ptypes[pos], ptypes[pos + 1], ptypes[pos + 2]);
725 case 4 -> mixer(ptypes[pos], ptypes[pos + 1], ptypes[pos + 2], ptypes[pos + 3]);
726 default -> throw new IllegalArgumentException("Unexpected count: " + count);
727 };
728 mix = MethodHandles.insertArguments(mix,0, initialLengthCoder);
729 // apply selected arguments on the 1-4 arg mixer and fold in the result
730 return switch (count) {
731 case 1 -> MethodHandles.foldArgumentsWithCombiner(mh, 0, mix,
732 1 + pos);
733 case 2 -> MethodHandles.foldArgumentsWithCombiner(mh, 0, mix,
734 1 + pos, 2 + pos);
735 case 3 -> MethodHandles.foldArgumentsWithCombiner(mh, 0, mix,
736 1 + pos, 2 + pos, 3 + pos);
737 case 4 -> MethodHandles.foldArgumentsWithCombiner(mh, 0, mix,
738 1 + pos, 2 + pos, 3 + pos, 4 + pos);
739 default -> throw new IllegalArgumentException();
740 };
741 }
742
743 // Simple prependers, single argument. May be used directly or as a
744 // building block for complex prepender combinators.
745 private static MethodHandle prepender(String prefix, Class<?> cl) {
746 if (prefix == null || prefix.isEmpty()) {
747 return noPrefixPrepender(cl);
748 } else {
749 return MethodHandles.insertArguments(
750 prepender(cl), 3, prefix);
751 }
752 }
753
754 private static MethodHandle prepender(Class<?> cl) {
755 int idx = classIndex(cl);
756 MethodHandle prepend = PREPENDERS[idx];
757 if (prepend == null) {
758 PREPENDERS[idx] = prepend = JLA.stringConcatHelper("prepend",
759 methodType(long.class, long.class, byte[].class,
760 Wrapper.asPrimitiveType(cl), String.class)).rebind();
761 }
762 return prepend;
763 }
764
765 private static MethodHandle noPrefixPrepender(Class<?> cl) {
766 int idx = classIndex(cl);
767 MethodHandle prepend = NO_PREFIX_PREPENDERS[idx];
768 if (prepend == null) {
769 NO_PREFIX_PREPENDERS[idx] = prepend = MethodHandles.insertArguments(prepender(cl), 3, "");
770 }
771 return prepend;
772 }
773
774 private static final int INT_IDX = 0,
775 CHAR_IDX = 1,
776 LONG_IDX = 2,
777 BOOLEAN_IDX = 3,
778 STRING_IDX = 4,
779 TYPE_COUNT = 5;
780 private static int classIndex(Class<?> cl) {
781 if (cl == String.class) return STRING_IDX;
782 if (cl == int.class) return INT_IDX;
783 if (cl == boolean.class) return BOOLEAN_IDX;
784 if (cl == char.class) return CHAR_IDX;
785 if (cl == long.class) return LONG_IDX;
786 throw new IllegalArgumentException("Unexpected class: " + cl);
787 }
788
789 // Constant argument lists used by the prepender MH builders
790 private static final int[] PREPEND_FILTER_FIRST_ARGS = new int[] { 0, 1, 2 };
791 private static final int[] PREPEND_FILTER_SECOND_ARGS = new int[] { 0, 1, 3 };
792 private static final int[] PREPEND_FILTER_THIRD_ARGS = new int[] { 0, 1, 4 };
793 private static final int[] PREPEND_FILTER_FIRST_PAIR_ARGS = new int[] { 0, 1, 2, 3 };
794 private static final int[] PREPEND_FILTER_SECOND_PAIR_ARGS = new int[] { 0, 1, 4, 5 };
795
796 // Base MH for complex prepender combinators.
797 private static @Stable MethodHandle PREPEND_BASE;
798 private static MethodHandle prependBase() {
799 MethodHandle base = PREPEND_BASE;
800 if (base == null) {
801 base = PREPEND_BASE = MethodHandles.dropArguments(
802 MethodHandles.identity(long.class), 1, byte[].class);
803 }
804 return base;
805 }
806
807 private static final @Stable MethodHandle[][] DOUBLE_PREPENDERS = new MethodHandle[TYPE_COUNT][TYPE_COUNT];
808
809 private static MethodHandle prepender(String prefix, Class<?> cl, String prefix2, Class<?> cl2) {
810 int idx1 = classIndex(cl);
811 int idx2 = classIndex(cl2);
812 MethodHandle prepend = DOUBLE_PREPENDERS[idx1][idx2];
813 if (prepend == null) {
814 prepend = DOUBLE_PREPENDERS[idx1][idx2] =
815 MethodHandles.dropArguments(prependBase(), 2, cl, cl2);
816 }
817 prepend = MethodHandles.filterArgumentsWithCombiner(prepend, 0, prepender(prefix, cl),
818 PREPEND_FILTER_FIRST_ARGS);
819 return MethodHandles.filterArgumentsWithCombiner(prepend, 0, prepender(prefix2, cl2),
820 PREPEND_FILTER_SECOND_ARGS);
821 }
822
823 private static MethodHandle prepender(int pos, String[] constants, Class<?>[] ptypes, int count) {
824 // build the simple cases directly
825 if (count == 1) {
826 return prepender(constants[pos], ptypes[pos]);
827 }
828 if (count == 2) {
829 return prepender(constants[pos], ptypes[pos], constants[pos + 1], ptypes[pos + 1]);
830 }
831 // build a tree from an unbound prepender, allowing us to bind the constants in a batch as a final step
832 MethodHandle prepend = prependBase();
833 if (count == 3) {
834 prepend = MethodHandles.dropArguments(prepend, 2,
835 ptypes[pos], ptypes[pos + 1], ptypes[pos + 2]);
836 prepend = MethodHandles.filterArgumentsWithCombiner(prepend, 0,
837 prepender(constants[pos], ptypes[pos], constants[pos + 1], ptypes[pos + 1]),
838 PREPEND_FILTER_FIRST_PAIR_ARGS);
839 return MethodHandles.filterArgumentsWithCombiner(prepend, 0,
840 prepender(constants[pos + 2], ptypes[pos + 2]),
841 PREPEND_FILTER_THIRD_ARGS);
842 } else if (count == 4) {
843 prepend = MethodHandles.dropArguments(prepend, 2,
844 ptypes[pos], ptypes[pos + 1], ptypes[pos + 2], ptypes[pos + 3]);
845 prepend = MethodHandles.filterArgumentsWithCombiner(prepend, 0,
846 prepender(constants[pos], ptypes[pos], constants[pos + 1], ptypes[pos + 1]),
847 PREPEND_FILTER_FIRST_PAIR_ARGS);
848 return MethodHandles.filterArgumentsWithCombiner(prepend, 0,
849 prepender(constants[pos + 2], ptypes[pos + 2], constants[pos + 3], ptypes[pos + 3]),
850 PREPEND_FILTER_SECOND_PAIR_ARGS);
851 } else {
852 throw new IllegalArgumentException("Unexpected count: " + count);
853 }
854 }
855
856 // Constant argument lists used by the mixer MH builders
857 private static final int[] MIX_FILTER_SECOND_ARGS = new int[] { 0, 2 };
858 private static final int[] MIX_FILTER_THIRD_ARGS = new int[] { 0, 3 };
859 private static final int[] MIX_FILTER_SECOND_PAIR_ARGS = new int[] { 0, 3, 4 };
860 private static MethodHandle mixer(Class<?> cl) {
861 int index = classIndex(cl);
862 MethodHandle mix = MIXERS[index];
863 if (mix == null) {
864 MIXERS[index] = mix = JLA.stringConcatHelper("mix",
865 methodType(long.class, long.class, Wrapper.asPrimitiveType(cl))).rebind();
866 }
867 return mix;
868 }
869
870 private static final @Stable MethodHandle[][] DOUBLE_MIXERS = new MethodHandle[TYPE_COUNT][TYPE_COUNT];
871 private static MethodHandle mixer(Class<?> cl, Class<?> cl2) {
872 int idx1 = classIndex(cl);
873 int idx2 = classIndex(cl2);
874 MethodHandle mix = DOUBLE_MIXERS[idx1][idx2];
875 if (mix == null) {
876 mix = mixer(cl);
877 mix = MethodHandles.dropArguments(mix, 2, cl2);
878 DOUBLE_MIXERS[idx1][idx2] = mix = MethodHandles.filterArgumentsWithCombiner(mix, 0,
879 mixer(cl2), MIX_FILTER_SECOND_ARGS);
880 }
881 return mix;
882 }
883
884 private static MethodHandle mixer(Class<?> cl, Class<?> cl2, Class<?> cl3) {
885 MethodHandle mix = mixer(cl, cl2);
886 mix = MethodHandles.dropArguments(mix, 3, cl3);
887 return MethodHandles.filterArgumentsWithCombiner(mix, 0,
888 mixer(cl3), MIX_FILTER_THIRD_ARGS);
889 }
890
891 private static MethodHandle mixer(Class<?> cl, Class<?> cl2, Class<?> cl3, Class<?> cl4) {
892 MethodHandle mix = mixer(cl, cl2);
893 mix = MethodHandles.dropArguments(mix, 3, cl3, cl4);
894 return MethodHandles.filterArgumentsWithCombiner(mix, 0,
895 mixer(cl3, cl4), MIX_FILTER_SECOND_PAIR_ARGS);
896 }
897
898 private @Stable static MethodHandle SIMPLE_CONCAT;
899 private static MethodHandle simpleConcat() {
900 MethodHandle mh = SIMPLE_CONCAT;
901 if (mh == null) {
902 MethodHandle simpleConcat = JLA.stringConcatHelper("simpleConcat",
903 methodType(String.class, Object.class, Object.class));
904 SIMPLE_CONCAT = mh = simpleConcat.rebind();
905 }
906 return mh;
907 }
908
909 private @Stable static MethodHandle NEW_STRING;
910 private static MethodHandle newString() {
911 MethodHandle mh = NEW_STRING;
912 if (mh == null) {
913 MethodHandle newString = JLA.stringConcatHelper("newString",
914 methodType(String.class, byte[].class, long.class));
915 NEW_STRING = mh = newString.rebind();
916 }
917 return mh;
918 }
919
920 private @Stable static MethodHandle NEW_ARRAY_SUFFIX;
921 private static MethodHandle newArrayWithSuffix(String suffix) {
922 MethodHandle mh = NEW_ARRAY_SUFFIX;
923 if (mh == null) {
924 MethodHandle newArrayWithSuffix = JLA.stringConcatHelper("newArrayWithSuffix",
925 methodType(byte[].class, String.class, long.class));
926 NEW_ARRAY_SUFFIX = mh = newArrayWithSuffix.rebind();
927 }
928 return MethodHandles.insertArguments(mh, 0, suffix);
929 }
930
931 /**
932 * Public gateways to public "stringify" methods. These methods have the
933 * form String apply(T obj), and normally delegate to {@code String.valueOf},
934 * depending on argument's type.
935 */
936 private @Stable static MethodHandle OBJECT_STRINGIFIER;
937 private static MethodHandle objectStringifier() {
938 MethodHandle mh = OBJECT_STRINGIFIER;
939 if (mh == null) {
940 OBJECT_STRINGIFIER = mh = JLA.stringConcatHelper("stringOf",
941 methodType(String.class, Object.class));
942 }
943 return mh;
944 }
945 private @Stable static MethodHandle FLOAT_STRINGIFIER;
946 private static MethodHandle floatStringifier() {
947 MethodHandle mh = FLOAT_STRINGIFIER;
948 if (mh == null) {
949 FLOAT_STRINGIFIER = mh = stringValueOf(float.class);
950 }
951 return mh;
952 }
953 private @Stable static MethodHandle DOUBLE_STRINGIFIER;
954 private static MethodHandle doubleStringifier() {
955 MethodHandle mh = DOUBLE_STRINGIFIER;
956 if (mh == null) {
957 DOUBLE_STRINGIFIER = mh = stringValueOf(double.class);
958 }
959 return mh;
960 }
961
962 private @Stable static MethodHandle INT_STRINGIFIER;
963 private static MethodHandle intStringifier() {
964 MethodHandle mh = INT_STRINGIFIER;
965 if (mh == null) {
966 INT_STRINGIFIER = mh = stringValueOf(int.class);
967 }
968 return mh;
969 }
970
971 private @Stable static MethodHandle LONG_STRINGIFIER;
972 private static MethodHandle longStringifier() {
973 MethodHandle mh = LONG_STRINGIFIER;
974 if (mh == null) {
975 LONG_STRINGIFIER = mh = stringValueOf(long.class);
976 }
977 return mh;
978 }
979
980 private @Stable static MethodHandle CHAR_STRINGIFIER;
981 private static MethodHandle charStringifier() {
982 MethodHandle mh = CHAR_STRINGIFIER;
983 if (mh == null) {
984 CHAR_STRINGIFIER = mh = stringValueOf(char.class);
985 }
986 return mh;
987 }
988
989 private @Stable static MethodHandle BOOLEAN_STRINGIFIER;
990 private static MethodHandle booleanStringifier() {
991 MethodHandle mh = BOOLEAN_STRINGIFIER;
992 if (mh == null) {
993 BOOLEAN_STRINGIFIER = mh = stringValueOf(boolean.class);
994 }
995 return mh;
996 }
997
998 private @Stable static MethodHandle NEW_STRINGIFIER;
999 private static MethodHandle newStringifier() {
1000 MethodHandle mh = NEW_STRINGIFIER;
1001 if (mh == null) {
1002 NEW_STRINGIFIER = mh = JLA.stringConcatHelper("newStringOf",
1003 methodType(String.class, Object.class));
1004 }
1005 return mh;
1006 }
1007
1008 private static MethodHandle unaryConcat(Class<?> cl) {
1009 if (!cl.isPrimitive()) {
1010 return newStringifier();
1011 } else if (cl == int.class || cl == short.class || cl == byte.class) {
1012 return intStringifier();
1013 } else if (cl == long.class) {
1014 return longStringifier();
1015 } else if (cl == char.class) {
1016 return charStringifier();
1017 } else if (cl == boolean.class) {
1018 return booleanStringifier();
1019 } else if (cl == float.class) {
1020 return floatStringifier();
1021 } else if (cl == double.class) {
1022 return doubleStringifier();
1023 } else {
1024 throw new InternalError("Unhandled type for unary concatenation: " + cl);
1025 }
1026 }
1027
1028 private static final @Stable MethodHandle[] NO_PREFIX_PREPENDERS = new MethodHandle[TYPE_COUNT];
1029 private static final @Stable MethodHandle[] PREPENDERS = new MethodHandle[TYPE_COUNT];
1030 private static final @Stable MethodHandle[] MIXERS = new MethodHandle[TYPE_COUNT];
1031 private static final long INITIAL_CODER = JLA.stringConcatInitialCoder();
1032
1033 /**
1034 * Promote integral types to int.
1035 */
1036 private static Class<?> promoteToIntType(Class<?> t) {
1037 // use int for subword integral types; still need special mixers
1038 // and prependers for char, boolean
1039 return t == byte.class || t == short.class ? int.class : t;
1040 }
1041
1042 /**
1043 * Returns a stringifier for references and floats/doubles only.
1044 * Always returns null for other primitives.
1045 *
1046 * @param t class to stringify
1047 * @return stringifier; null, if not available
1048 */
1049 private static MethodHandle stringifierFor(Class<?> t) {
1050 if (t == Object.class) {
1051 return objectStringifier();
1052 } else if (t == float.class) {
1053 return floatStringifier();
1054 } else if (t == double.class) {
1055 return doubleStringifier();
1056 }
1057 return null;
1058 }
1059
1060 private static MethodHandle stringValueOf(Class<?> ptype) {
1061 try {
1062 return MethodHandles.publicLookup()
1063 .findStatic(String.class, "valueOf", MethodType.methodType(String.class, ptype));
1064 } catch (NoSuchMethodException | IllegalAccessException e) {
1065 throw new AssertionError(e);
1066 }
1067 }
1068
1069 private StringConcatFactory() {
1070 // no instantiation
1071 }
1072
1073 /**
1074 * Implement efficient hidden class strategy for String concatenation
1075 *
1076 * <p>This strategy replicates based on the bytecode what StringBuilders are doing: it builds the
1077 * byte[] array on its own and passes that byte[] array to String
1078 * constructor. This strategy requires access to some private APIs in JDK,
1079 * most notably, the private String constructor that accepts byte[] arrays
1080 * without copying.
1081 */
1082 private static final class InlineHiddenClassStrategy {
1083 static final String CLASS_NAME = "java.lang.String$$StringConcat";
1084 static final String METHOD_NAME = "concat";
1085
1086 static final ClassFileDumper DUMPER =
1087 ClassFileDumper.getInstance("java.lang.invoke.StringConcatFactory.dump", "stringConcatClasses");
1088 static final MethodHandles.Lookup STR_LOOKUP = new MethodHandles.Lookup(String.class);
1089
1090 static final ClassDesc CD_CONCAT = ConstantUtils.binaryNameToDesc(CLASS_NAME);
1091 static final ClassDesc CD_StringConcatHelper = ReferenceClassDescImpl.ofValidated("Ljava/lang/StringConcatHelper;");
1092 static final ClassDesc CD_StringConcatBase = ReferenceClassDescImpl.ofValidated("Ljava/lang/StringConcatHelper$StringConcatBase;");
1093 static final ClassDesc CD_Array_byte = ReferenceClassDescImpl.ofValidated("[B");
1094 static final ClassDesc CD_Array_String = ReferenceClassDescImpl.ofValidated("[Ljava/lang/String;");
1095
1096 static final MethodTypeDesc MTD_byte_char = MethodTypeDescImpl.ofValidated(CD_byte, CD_char);
1097 static final MethodTypeDesc MTD_byte = MethodTypeDescImpl.ofValidated(CD_byte);
1098 static final MethodTypeDesc MTD_int = MethodTypeDescImpl.ofValidated(CD_int);
1099 static final MethodTypeDesc MTD_int_int_boolean = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_boolean);
1100 static final MethodTypeDesc MTD_int_int_char = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_char);
1101 static final MethodTypeDesc MTD_int_int_int = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_int);
1102 static final MethodTypeDesc MTD_int_int_long = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_long);
1103 static final MethodTypeDesc MTD_int_int_String = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_String);
1104 static final MethodTypeDesc MTD_String_float = MethodTypeDescImpl.ofValidated(CD_String, CD_float);
1105 static final MethodTypeDesc MTD_String_double = MethodTypeDescImpl.ofValidated(CD_String, CD_double);
1106 static final MethodTypeDesc MTD_String_Object = MethodTypeDescImpl.ofValidated(CD_String, CD_Object);
1107
1108 static final MethodTypeDesc MTD_INIT = MethodTypeDescImpl.ofValidated(CD_void, CD_Array_String);
1109 static final MethodTypeDesc MTD_NEW_ARRAY_SUFFIX = MethodTypeDescImpl.ofValidated(CD_Array_byte, CD_String, CD_int, CD_byte);
1110 static final MethodTypeDesc MTD_STRING_INIT = MethodTypeDescImpl.ofValidated(CD_void, CD_Array_byte, CD_byte);
1111
1112 static final MethodTypeDesc PREPEND_int = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_byte, CD_Array_byte, CD_int, CD_String);
1113 static final MethodTypeDesc PREPEND_long = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_byte, CD_Array_byte, CD_long, CD_String);
1114 static final MethodTypeDesc PREPEND_boolean = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_byte, CD_Array_byte, CD_boolean, CD_String);
1115 static final MethodTypeDesc PREPEND_char = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_byte, CD_Array_byte, CD_char, CD_String);
1116 static final MethodTypeDesc PREPEND_String = MethodTypeDescImpl.ofValidated(CD_int, CD_int, CD_byte, CD_Array_byte, CD_String, CD_String);
1117
1118 static final RuntimeVisibleAnnotationsAttribute FORCE_INLINE = RuntimeVisibleAnnotationsAttribute.of(Annotation.of(ClassDesc.ofDescriptor("Ljdk/internal/vm/annotation/ForceInline;")));
1119
1120 static final MethodType CONSTRUCTOR_METHOD_TYPE = MethodType.methodType(void.class, String[].class);
1121 static final Consumer<CodeBuilder> CONSTRUCTOR_BUILDER = new Consumer<CodeBuilder>() {
1122 @Override
1123 public void accept(CodeBuilder cb) {
1124 /*
1125 * super(constants);
1126 */
1127 int thisSlot = cb.receiverSlot(),
1128 constantsSlot = cb.parameterSlot(0);
1129 cb.aload(thisSlot)
1130 .aload(constantsSlot)
1131 .invokespecial(CD_StringConcatBase, INIT_NAME, MTD_INIT, false)
1132 .return_();
1133 }
1134 };
1135
1136 static final ReferencedKeyMap<MethodType, SoftReference<MethodHandlePair>> CACHE =
1137 ReferencedKeyMap.create(true,
1138 new Supplier<>() {
1139 @Override
1140 public Map<ReferenceKey<MethodType>, SoftReference<MethodHandlePair>> get() {
1141 return new ConcurrentHashMap<>(64);
1142 }
1143 });
1144
1145 private InlineHiddenClassStrategy() {
1146 // no instantiation
1147 }
1148
1149 private record MethodHandlePair(MethodHandle constructor, MethodHandle concatenator) { };
1150
1151 /**
1152 * The parameter types are normalized into 7 types: int,long,boolean,char,float,double,Object
1153 */
1154 private static MethodType erasedArgs(MethodType args) {
1155 int parameterCount = args.parameterCount();
1156 var paramTypes = new Class<?>[parameterCount];
1157 boolean changed = false;
1158 for (int i = 0; i < parameterCount; i++) {
1159 Class<?> cl = args.parameterType(i);
1160 // Use int as the logical type for subword integral types
1161 // (byte and short). char and boolean require special
1162 // handling so don't change the logical type of those
1163 if (cl == byte.class || cl == short.class) {
1164 cl = int.class;
1165 changed = true;
1166 } else if (cl != Object.class && !cl.isPrimitive()) {
1167 cl = Object.class;
1168 changed = true;
1169 }
1170 paramTypes[i] = cl;
1171 }
1172 return changed ? MethodType.methodType(args.returnType(), paramTypes, true) : args;
1173 }
1174
1175 /**
1176 * Construct the MethodType of the prepend method, The parameters only support 5 types:
1177 * int/long/char/boolean/String. Not int/long/char/boolean type, use String type<p>
1178 *
1179 * The following is an example of the generated target code:
1180 * <blockquote><pre>
1181 * int prepend(int length, byte coder, byte[] buff, String[] constants
1182 * int arg0, long arg1, boolean arg2, char arg3, String arg5)
1183 * </pre></blockquote>
1184 */
1185 private static MethodTypeDesc prependArgs(MethodType concatArgs, boolean staticConcat) {
1186 int parameterCount = concatArgs.parameterCount();
1187 int prefixArgs = staticConcat ? 3 : 4;
1188 var paramTypes = new ClassDesc[parameterCount + prefixArgs];
1189 paramTypes[0] = CD_int; // length
1190 paramTypes[1] = CD_byte; // coder
1191 paramTypes[2] = CD_Array_byte; // buff
1192
1193 if (!staticConcat) {
1194 paramTypes[3] = CD_Array_String; // constants
1195 }
1196
1197 for (int i = 0; i < parameterCount; i++) {
1198 var cl = concatArgs.parameterType(i);
1199 paramTypes[i + prefixArgs] = needStringOf(cl) ? CD_String : ConstantUtils.classDesc(cl);
1200 }
1201 return MethodTypeDescImpl.ofValidated(CD_int, paramTypes);
1202 }
1203
1204 /**
1205 * Construct the MethodType of the coder method. The first parameter is the initialized coder.
1206 * Only parameter types which can be UTF16 are added.
1207 * Returns null if no such parameter exists or CompactStrings is off.
1208 */
1209 private static MethodTypeDesc coderArgsIfMaybeUTF16(MethodType concatArgs) {
1210 if (JLA.stringInitCoder() != 0) {
1211 return null;
1212 }
1213
1214 int parameterCount = concatArgs.parameterCount();
1215
1216 int maybeUTF16Count = 0;
1217 for (int i = 0; i < parameterCount; i++) {
1218 if (maybeUTF16(concatArgs.parameterType(i))) {
1219 maybeUTF16Count++;
1220 }
1221 }
1222
1223 if (maybeUTF16Count == 0) {
1224 return null;
1225 }
1226
1227 var paramTypes = new ClassDesc[maybeUTF16Count + 1];
1228 paramTypes[0] = CD_int; // init coder
1229 for (int i = 0, paramIndex = 1; i < parameterCount; i++) {
1230 var cl = concatArgs.parameterType(i);
1231 if (maybeUTF16(cl)) {
1232 paramTypes[paramIndex++] = cl == char.class ? CD_char : CD_String;
1233 }
1234 }
1235 return MethodTypeDescImpl.ofValidated(CD_int, paramTypes);
1236 }
1237
1238 /**
1239 * Construct the MethodType of the length method,
1240 * The first parameter is the initialized length
1241 */
1242 private static MethodTypeDesc lengthArgs(MethodType concatArgs) {
1243 int parameterCount = concatArgs.parameterCount();
1244 var paramTypes = new ClassDesc[parameterCount + 1];
1245 paramTypes[0] = CD_int; // init long
1246 for (int i = 0; i < parameterCount; i++) {
1247 var cl = concatArgs.parameterType(i);
1248 paramTypes[i + 1] = needStringOf(cl) ? CD_String : ConstantUtils.classDesc(cl);
1249 }
1250 return MethodTypeDescImpl.ofValidated(CD_int, paramTypes);
1251 }
1252
1253 private static MethodHandle generate(Lookup lookup, MethodType args, String[] constants) throws Exception {
1254 lookup = STR_LOOKUP;
1255 final MethodType concatArgs = erasedArgs(args);
1256
1257 // 1 argument use built-in method
1258 if (args.parameterCount() == 1) {
1259 Object concat1 = JLA.stringConcat1(constants);
1260 var handle = lookup.findVirtual(concat1.getClass(), METHOD_NAME, concatArgs);
1261 return handle.bindTo(concat1);
1262 }
1263
1264 boolean forceInline = concatArgs.parameterCount() < FORCE_INLINE_THRESHOLD;
1265 boolean staticConcat = concatArgs.parameterCount() >= CACHE_THRESHOLD;
1266
1267 if (!staticConcat) {
1268 var weakConstructorHandle = CACHE.get(concatArgs);
1269 if (weakConstructorHandle != null) {
1270 MethodHandlePair handlePair = weakConstructorHandle.get();
1271 if (handlePair != null) {
1272 try {
1273 var instance = handlePair.constructor.invokeBasic((Object)constants);
1274 return handlePair.concatenator.bindTo(instance);
1275 } catch (Throwable e) {
1276 throw new StringConcatException("Exception while utilizing the hidden class", e);
1277 }
1278 }
1279 }
1280 }
1281
1282 MethodTypeDesc lengthArgs = lengthArgs(concatArgs),
1283 coderArgs = coderArgsIfMaybeUTF16(concatArgs),
1284 prependArgs = prependArgs(concatArgs, staticConcat);
1285
1286 byte[] classBytes = ClassFile.of().build(CD_CONCAT,
1287 new Consumer<ClassBuilder>() {
1288 @Override
1289 public void accept(ClassBuilder clb) {
1290 if (staticConcat) {
1291 clb.withSuperclass(CD_Object)
1292 .withFlags(ACC_ABSTRACT | ACC_SUPER | ACC_SYNTHETIC);
1293 } else {
1294 clb.withSuperclass(CD_StringConcatBase)
1295 .withFlags(ACC_FINAL | ACC_SUPER | ACC_SYNTHETIC)
1296 .withMethodBody(INIT_NAME, MTD_INIT, 0, CONSTRUCTOR_BUILDER);
1297 }
1298
1299 clb.withMethod("length",
1300 lengthArgs,
1301 ACC_STATIC | ACC_PRIVATE,
1302 new Consumer<MethodBuilder>() {
1303 public void accept(MethodBuilder mb) {
1304 if (forceInline) {
1305 mb.with(FORCE_INLINE);
1306 }
1307 mb.withCode(generateLengthMethod(lengthArgs));
1308 }
1309 })
1310 .withMethod("prepend",
1311 prependArgs,
1312 ACC_STATIC | ACC_PRIVATE,
1313 new Consumer<MethodBuilder>() {
1314 public void accept(MethodBuilder mb) {
1315 if (forceInline) {
1316 mb.with(FORCE_INLINE);
1317 }
1318 mb.withCode(generatePrependMethod(prependArgs, staticConcat, constants));
1319 }
1320 })
1321 .withMethod(METHOD_NAME,
1322 ConstantUtils.methodTypeDesc(concatArgs),
1323 staticConcat ? ACC_STATIC | ACC_FINAL : ACC_FINAL,
1324 new Consumer<MethodBuilder>() {
1325 public void accept(MethodBuilder mb) {
1326 if (forceInline) {
1327 mb.with(FORCE_INLINE);
1328 }
1329 mb.withCode(generateConcatMethod(
1330 staticConcat,
1331 constants,
1332 CD_CONCAT,
1333 concatArgs,
1334 lengthArgs,
1335 coderArgs,
1336 prependArgs));
1337 }
1338 });
1339
1340 if (coderArgs != null) {
1341 clb.withMethod("coder",
1342 coderArgs,
1343 ACC_STATIC | ACC_PRIVATE,
1344 new Consumer<MethodBuilder>() {
1345 public void accept(MethodBuilder mb) {
1346 if (forceInline) {
1347 mb.with(FORCE_INLINE);
1348 }
1349 mb.withCode(generateCoderMethod(coderArgs));
1350 }
1351 });
1352 }
1353 }});
1354 try {
1355 var hiddenClass = lookup.makeHiddenClassDefiner(CLASS_NAME, classBytes, DUMPER)
1356 .defineClass(true, null);
1357
1358 if (staticConcat) {
1359 return lookup.findStatic(hiddenClass, METHOD_NAME, concatArgs);
1360 }
1361
1362 var constructor = lookup.findConstructor(hiddenClass, CONSTRUCTOR_METHOD_TYPE);
1363 var concatenator = lookup.findVirtual(hiddenClass, METHOD_NAME, concatArgs);
1364 CACHE.put(concatArgs, new SoftReference<>(new MethodHandlePair(constructor, concatenator)));
1365 var instance = constructor.invokeBasic((Object)constants);
1366 return concatenator.bindTo(instance);
1367 } catch (Throwable e) {
1368 throw new StringConcatException("Exception while spinning the class", e);
1369 }
1370 }
1371
1372 /**
1373 * Generate InlineCopy-based code. <p>
1374 *
1375 * The following is an example of the generated target code:
1376 *
1377 * <blockquote><pre>
1378 * import static java.lang.StringConcatHelper.newArrayWithSuffix;
1379 * import static java.lang.StringConcatHelper.prepend;
1380 * import static java.lang.StringConcatHelper.stringCoder;
1381 * import static java.lang.StringConcatHelper.stringSize;
1382 *
1383 * class StringConcat extends java.lang.StringConcatHelper.StringConcatBase {
1384 * // super class defines
1385 * // String[] constants;
1386 * // int length;
1387 * // byte coder;
1388 *
1389 * StringConcat(String[] constants) {
1390 * super(constants);
1391 * }
1392 *
1393 * String concat(int arg0, long arg1, boolean arg2, char arg3, String arg4,
1394 * float arg5, double arg6, Object arg7
1395 * ) {
1396 * // Types other than byte/short/int/long/boolean/String require a local variable to store
1397 * String str4 = stringOf(arg4);
1398 * String str5 = stringOf(arg5);
1399 * String str6 = stringOf(arg6);
1400 * String str7 = stringOf(arg7);
1401 *
1402 * int coder = coder(this.coder, arg0, arg1, arg2, arg3, str4, str5, str6, str7);
1403 * int length = length(this.length, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1404 * String[] constants = this.constants;
1405 * byte[] buf = newArrayWithSuffix(constants[paramCount], length. coder);
1406 *
1407 * prepend(length, coder, buf, constants, arg0, arg1, arg2, arg3, str4, str5, str6, str7);
1408 *
1409 * return new String(buf, coder);
1410 * }
1411 *
1412 * static int length(int length, int arg0, long arg1, boolean arg2, char arg3,
1413 * String arg4, String arg5, String arg6, String arg7) {
1414 * return stringSize(stringSize(stringSize(stringSize(stringSize(stringSize(stringSize(stringSize(
1415 * length, arg0), arg1), arg2), arg3), arg4), arg5), arg6), arg7);
1416 * }
1417 *
1418 * static int cocder(int coder, char arg3, String str4, String str5, String str6, String str7) {
1419 * return coder | stringCoder(arg3) | str4.coder() | str5.coder() | str6.coder() | str7.coder();
1420 * }
1421 *
1422 * static int prepend(int length, int coder, byte[] buf, String[] constants,
1423 * int arg0, long arg1, boolean arg2, char arg3,
1424 * String str4, String str5, String str6, String str7) {
1425 * // StringConcatHelper.prepend
1426 * return prepend(prepend(prepend(prepend(
1427 * prepend(apppend(prepend(prepend(length,
1428 * buf, str7, constant[7]), buf, str6, constant[6]),
1429 * buf, str5, constant[5]), buf, str4, constant[4]),
1430 * buf, arg3, constant[3]), buf, arg2, constant[2]),
1431 * buf, arg1, constant[1]), buf, arg0, constant[0]);
1432 * }
1433 * }
1434 * </pre></blockquote>
1435 */
1436 private static Consumer<CodeBuilder> generateConcatMethod(
1437 boolean staticConcat,
1438 String[] constants,
1439 ClassDesc concatClass,
1440 MethodType concatArgs,
1441 MethodTypeDesc lengthArgs,
1442 MethodTypeDesc coderArgs,
1443 MethodTypeDesc prependArgs
1444 ) {
1445 return new Consumer<CodeBuilder>() {
1446 @Override
1447 public void accept(CodeBuilder cb) {
1448 // Compute parameter variable slots
1449 int paramCount = concatArgs.parameterCount(),
1450 thisSlot = staticConcat ? 0 : cb.receiverSlot(),
1451 lengthSlot = cb.allocateLocal(TypeKind.INT),
1452 coderSlot = cb.allocateLocal(TypeKind.BYTE),
1453 bufSlot = cb.allocateLocal(TypeKind.REFERENCE),
1454 constantsSlot = cb.allocateLocal(TypeKind.REFERENCE),
1455 suffixSlot = cb.allocateLocal(TypeKind.REFERENCE);
1456
1457 /*
1458 * Types other than int/long/char/boolean require local variables to store the result of stringOf.
1459 *
1460 * stringSlots stores the slots of parameters relative to local variables
1461 *
1462 * str0 = stringOf(arg0);
1463 * str1 = stringOf(arg1);
1464 * ...
1465 * strN = toString(argN);
1466 */
1467 int[] stringSlots = new int[paramCount];
1468 for (int i = 0; i < paramCount; i++) {
1469 var cl = concatArgs.parameterType(i);
1470 if (needStringOf(cl)) {
1471 MethodTypeDesc methodTypeDesc;
1472 if (cl == float.class) {
1473 methodTypeDesc = MTD_String_float;
1474 } else if (cl == double.class) {
1475 methodTypeDesc = MTD_String_double;
1476 } else {
1477 methodTypeDesc = MTD_String_Object;
1478 }
1479 stringSlots[i] = cb.allocateLocal(TypeKind.REFERENCE);
1480 cb.loadLocal(TypeKind.from(cl), cb.parameterSlot(i))
1481 .invokestatic(CD_StringConcatHelper, "stringOf", methodTypeDesc)
1482 .astore(stringSlots[i]);
1483 }
1484 }
1485
1486 int coder = JLA.stringInitCoder(),
1487 length = 0;
1488 if (staticConcat) {
1489 for (var constant : constants) {
1490 coder |= JLA.stringCoder(constant);
1491 length += constant.length();
1492 }
1493 }
1494
1495 /*
1496 * coder = coder(this.coder, arg0, arg1, ... argN);
1497 */
1498 if (staticConcat) {
1499 // coder can only be 0 or 1
1500 if (coder == 0) {
1501 cb.iconst_0();
1502 } else {
1503 cb.iconst_1();
1504 }
1505 } else {
1506 cb.aload(thisSlot)
1507 .getfield(concatClass, "coder", CD_byte);
1508 }
1509
1510 if (coderArgs != null) {
1511 for (int i = 0; i < paramCount; i++) {
1512 var cl = concatArgs.parameterType(i);
1513 if (maybeUTF16(cl)) {
1514 if (cl == char.class) {
1515 cb.loadLocal(TypeKind.CHAR, cb.parameterSlot(i));
1516 } else {
1517 cb.aload(stringSlots[i]);
1518 }
1519 }
1520 }
1521 cb.invokestatic(concatClass, "coder", coderArgs);
1522 }
1523 cb.istore(coderSlot);
1524
1525 /*
1526 * length = length(this.length, arg0, arg1, ..., argN);
1527 */
1528 if (staticConcat) {
1529 cb.loadConstant(length);
1530 } else {
1531 cb.aload(thisSlot)
1532 .getfield(concatClass, "length", CD_int);
1533 }
1534
1535 for (int i = 0; i < paramCount; i++) {
1536 var cl = concatArgs.parameterType(i);
1537 int paramSlot = cb.parameterSlot(i);
1538 if (needStringOf(cl)) {
1539 paramSlot = stringSlots[i];
1540 cl = String.class;
1541 }
1542 cb.loadLocal(TypeKind.from(cl), paramSlot);
1543 }
1544 cb.invokestatic(concatClass, "length", lengthArgs);
1545
1546 /*
1547 * String[] constants = this.constants;
1548 * suffix = constants[paramCount];
1549 * length -= suffix.length();
1550 */
1551 if (staticConcat) {
1552 cb.loadConstant(constants[paramCount].length())
1553 .isub()
1554 .istore(lengthSlot);
1555 } else {
1556 cb.aload(thisSlot)
1557 .getfield(concatClass, "constants", CD_Array_String)
1558 .dup()
1559 .astore(constantsSlot)
1560 .loadConstant(paramCount)
1561 .aaload()
1562 .dup()
1563 .astore(suffixSlot)
1564 .invokevirtual(CD_String, "length", MTD_int)
1565 .isub()
1566 .istore(lengthSlot);
1567 }
1568
1569 /*
1570 * Allocate buffer :
1571 *
1572 * buf = newArrayWithSuffix(suffix, length, coder)
1573 */
1574 if (staticConcat) {
1575 cb.loadConstant(constants[paramCount]);
1576 } else {
1577 cb.aload(suffixSlot);
1578 }
1579 cb.iload(lengthSlot)
1580 .iload(coderSlot)
1581 .invokestatic(CD_StringConcatHelper, "newArrayWithSuffix", MTD_NEW_ARRAY_SUFFIX)
1582 .astore(bufSlot);
1583
1584 /*
1585 * prepend(length, coder, buf, constants, ar0, ar1, ..., argN);
1586 */
1587 cb.iload(lengthSlot)
1588 .iload(coderSlot)
1589 .aload(bufSlot);
1590 if (!staticConcat) {
1591 cb.aload(constantsSlot);
1592 }
1593 for (int i = 0; i < paramCount; i++) {
1594 var cl = concatArgs.parameterType(i);
1595 int paramSlot = cb.parameterSlot(i);
1596 var kind = TypeKind.from(cl);
1597 if (needStringOf(cl)) {
1598 paramSlot = stringSlots[i];
1599 kind = TypeKind.REFERENCE;
1600 }
1601 cb.loadLocal(kind, paramSlot);
1602 }
1603 cb.invokestatic(concatClass, "prepend", prependArgs);
1604
1605 // return new String(buf, coder);
1606 cb.new_(CD_String)
1607 .dup()
1608 .aload(bufSlot)
1609 .iload(coderSlot)
1610 .invokespecial(CD_String, INIT_NAME, MTD_STRING_INIT)
1611 .areturn();
1612 }
1613 };
1614 }
1615
1616 /**
1617 * Generate length method. <p>
1618 *
1619 * The following is an example of the generated target code:
1620 *
1621 * <blockquote><pre>
1622 * import static java.lang.StringConcatHelper.stringSize;
1623 *
1624 * static int length(int length, int arg0, long arg1, boolean arg2, char arg3,
1625 * String arg4, String arg5, String arg6, String arg7) {
1626 * return stringSize(stringSize(stringSize(length, arg0), arg1), ..., arg7);
1627 * }
1628 * </pre></blockquote>
1629 */
1630 private static Consumer<CodeBuilder> generateLengthMethod(MethodTypeDesc lengthArgs) {
1631 return new Consumer<CodeBuilder>() {
1632 @Override
1633 public void accept(CodeBuilder cb) {
1634 int lengthSlot = cb.parameterSlot(0);
1635 cb.iload(lengthSlot);
1636 for (int i = 1; i < lengthArgs.parameterCount(); i++) {
1637 var cl = lengthArgs.parameterType(i);
1638 MethodTypeDesc methodTypeDesc;
1639 if (cl == CD_char) {
1640 methodTypeDesc = MTD_int_int_char;
1641 } else if (cl == CD_int) {
1642 methodTypeDesc = MTD_int_int_int;
1643 } else if (cl == CD_long) {
1644 methodTypeDesc = MTD_int_int_long;
1645 } else if (cl == CD_boolean) {
1646 methodTypeDesc = MTD_int_int_boolean;
1647 } else {
1648 methodTypeDesc = MTD_int_int_String;
1649 }
1650 cb.loadLocal(TypeKind.from(cl), cb.parameterSlot(i))
1651 .invokestatic(CD_StringConcatHelper, "stringSize", methodTypeDesc);
1652 }
1653 cb.ireturn();
1654 }
1655 };
1656 }
1657
1658 /**
1659 * Generate coder method. <p>
1660 *
1661 * The following is an example of the generated target code:
1662 *
1663 * <blockquote><pre>
1664 * import static java.lang.StringConcatHelper.stringCoder;
1665 *
1666 * static int cocder(int coder, char arg3, String str4, String str5, String str6, String str7) {
1667 * return coder | stringCoder(arg3) | str4.coder() | str5.coder() | str6.coder() | str7.coder();
1668 * }
1669 * </pre></blockquote>
1670 */
1671 private static Consumer<CodeBuilder> generateCoderMethod(MethodTypeDesc coderArgs) {
1672 return new Consumer<CodeBuilder>() {
1673 @Override
1674 public void accept(CodeBuilder cb) {
1675 /*
1676 * return coder | stringCoder(argN) | ... | arg1.coder() | arg0.coder();
1677 */
1678 int coderSlot = cb.parameterSlot(0);
1679 cb.iload(coderSlot);
1680 for (int i = 1; i < coderArgs.parameterCount(); i++) {
1681 var cl = coderArgs.parameterType(i);
1682 cb.loadLocal(TypeKind.from(cl), cb.parameterSlot(i));
1683 if (cl == CD_char) {
1684 cb.invokestatic(CD_StringConcatHelper, "stringCoder", MTD_byte_char);
1685 } else {
1686 cb.invokevirtual(CD_String, "coder", MTD_byte);
1687 }
1688 cb.ior();
1689 }
1690 cb.ireturn();
1691 }
1692 };
1693 }
1694
1695 /**
1696 * Generate prepend method. <p>
1697 *
1698 * The following is an example of the generated target code:
1699 *
1700 * <blockquote><pre>
1701 * import static java.lang.StringConcatHelper.prepend;
1702 *
1703 * static int prepend(int length, int coder, byte[] buf, String[] constants,
1704 * int arg0, long arg1, boolean arg2, char arg3,
1705 * String str4, String str5, String str6, String str7) {
1706 *
1707 * return prepend(prepend(prepend(prepend(
1708 * prepend(prepend(prepend(prepend(length,
1709 * buf, str7, constant[7]), buf, str6, constant[6]),
1710 * buf, str5, constant[5]), buf, str4, constant[4]),
1711 * buf, arg3, constant[3]), buf, arg2, constant[2]),
1712 * buf, arg1, constant[1]), buf, arg0, constant[0]);
1713 * }
1714 * </pre></blockquote>
1715 */
1716 private static Consumer<CodeBuilder> generatePrependMethod(
1717 MethodTypeDesc prependArgs,
1718 boolean staticConcat, String[] constants
1719 ) {
1720 return new Consumer<CodeBuilder>() {
1721 @Override
1722 public void accept(CodeBuilder cb) {
1723 // Compute parameter variable slots
1724 int lengthSlot = cb.parameterSlot(0),
1725 coderSlot = cb.parameterSlot(1),
1726 bufSlot = cb.parameterSlot(2),
1727 constantsSlot = cb.parameterSlot(3);
1728 /*
1729 * // StringConcatHelper.prepend
1730 * return prepend(prepend(prepend(prepend(
1731 * prepend(apppend(prepend(prepend(length,
1732 * buf, str7, constant[7]), buf, str6, constant[6]),
1733 * buf, str5, constant[5]), buf, arg4, constant[4]),
1734 * buf, arg3, constant[3]), buf, arg2, constant[2]),
1735 * buf, arg1, constant[1]), buf, arg0, constant[0]);
1736 */
1737 cb.iload(lengthSlot);
1738 for (int i = prependArgs.parameterCount() - 1, end = staticConcat ? 3 : 4; i >= end; i--) {
1739 var cl = prependArgs.parameterType(i);
1740 var kind = TypeKind.from(cl);
1741
1742 // There are only 5 types of parameters: int, long, boolean, char, String
1743 MethodTypeDesc methodTypeDesc;
1744 if (cl == CD_int) {
1745 methodTypeDesc = PREPEND_int;
1746 } else if (cl == CD_long) {
1747 methodTypeDesc = PREPEND_long;
1748 } else if (cl == CD_boolean) {
1749 methodTypeDesc = PREPEND_boolean;
1750 } else if (cl == CD_char) {
1751 methodTypeDesc = PREPEND_char;
1752 } else {
1753 kind = TypeKind.REFERENCE;
1754 methodTypeDesc = PREPEND_String;
1755 }
1756
1757 cb.iload(coderSlot)
1758 .aload(bufSlot)
1759 .loadLocal(kind, cb.parameterSlot(i));
1760
1761 if (staticConcat) {
1762 cb.loadConstant(constants[i - 3]);
1763 } else {
1764 cb.aload(constantsSlot)
1765 .loadConstant(i - 4)
1766 .aaload();
1767 }
1768
1769 cb.invokestatic(CD_StringConcatHelper, "prepend", methodTypeDesc);
1770 }
1771 cb.ireturn();
1772 }
1773 };
1774 }
1775
1776 static boolean needStringOf(Class<?> cl) {
1777 return cl != int.class && cl != long.class && cl != boolean.class && cl != char.class;
1778 }
1779
1780 static boolean maybeUTF16(Class<?> cl) {
1781 return cl == char.class || !cl.isPrimitive();
1782 }
1783 }
1784 }