rev 15353 : 8164044: Generate the corresponding BoundMethodHandle to all generated DirectMethodHandles
Reviewed-by: vlivanov, mhaupt

   1 /*
   2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package jdk.tools.jlink.internal.plugins;
  26 
  27 import java.lang.invoke.MethodType;
  28 import java.util.Arrays;
  29 import java.util.EnumSet;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Set;
  34 import java.util.stream.Collectors;
  35 import jdk.internal.misc.SharedSecrets;
  36 import jdk.internal.misc.JavaLangInvokeAccess;
  37 import jdk.tools.jlink.plugin.ResourcePoolEntry;
  38 import jdk.tools.jlink.plugin.PluginException;
  39 import jdk.tools.jlink.plugin.ResourcePool;
  40 import jdk.tools.jlink.plugin.ResourcePoolBuilder;
  41 import jdk.tools.jlink.plugin.Plugin;
  42 
  43 /**
  44  * Plugin to generate java.lang.invoke classes.
  45  */
  46 public final class GenerateJLIClassesPlugin implements Plugin {
  47 
  48     private static final String NAME = "generate-jli-classes";
  49 
  50     private static final String BMH_PARAM = "bmh";
  51 
  52     private static final String BMH_SPECIES_PARAM = "bmh-species";
  53 
  54     private static final String DMH_PARAM = "dmh";
  55 
  56     private static final String DESCRIPTION = PluginsResourceBundle.getDescription(NAME);
  57 
  58     private static final String DMH = "java/lang/invoke/DirectMethodHandle$Holder";
  59     private static final String DMH_INVOKE_VIRTUAL = "invokeVirtual";
  60     private static final String DMH_INVOKE_STATIC = "invokeStatic";
  61     private static final String DMH_INVOKE_SPECIAL = "invokeSpecial";
  62     private static final String DMH_NEW_INVOKE_SPECIAL = "newInvokeSpecial";
  63     private static final String DMH_INVOKE_INTERFACE = "invokeInterface";
  64     private static final String DMH_INVOKE_STATIC_INIT = "invokeStaticInit";
  65 


  66     private static final JavaLangInvokeAccess JLIA
  67             = SharedSecrets.getJavaLangInvokeAccess();
  68 
  69     List<String> speciesTypes;
  70 
  71     Map<String, List<String>> dmhMethods;
  72 
  73     public GenerateJLIClassesPlugin() {
  74     }
  75 
  76     @Override
  77     public String getName() {
  78         return NAME;
  79     }
  80 
  81     @Override
  82     public String getDescription() {
  83         return DESCRIPTION;
  84     }
  85 
  86     @Override
  87     public Set<State> getState() {
  88         return EnumSet.of(State.AUTO_ENABLED, State.FUNCTIONAL);
  89     }
  90 
  91     @Override
  92     public boolean hasArguments() {
  93         return true;
  94     }
  95 
  96     @Override
  97     public String getArgumentsDescription() {
  98        return PluginsResourceBundle.getArgument(NAME);
  99     }
 100 
 101     /**
 102      * @return the default Species forms to generate.
 103      *
 104      * This list was derived from running a small startup benchmark.
 105      * A better long-term solution is to define and run a set of quick
 106      * generators and extracting this list as a step in the build process.
 107      */
 108     public static List<String> defaultSpecies() {
 109         return List.of("LL", "L3", "L4", "L5", "L6", "L7", "L7I",
 110                 "L7II", "L7IIL", "L8", "L9", "L10", "L10I", "L10II", "L10IIL",
 111                 "L11", "L12", "L13", "LI", "D", "L3I", "LIL", "LLI", "LLIL",
 112                 "LILL", "I", "LLILL");
 113     }
 114 
 115     /**
 116      * @return the list of default DirectMethodHandle methods to generate.
 117      */
 118     public static Map<String, List<String>> defaultDMHMethods() {
 119         return Map.of(
 120             DMH_INVOKE_VIRTUAL, List.of("_L", "L_L", "LI_I", "LL_V"),
 121             DMH_INVOKE_SPECIAL, List.of("L_I", "L_L", "LF_L", "LD_L", "LL_L",
 122                 "L3_L", "L4_L", "L5_L", "L6_L", "L7_L", "LI_I", "LI_L", "LIL_I",
 123                 "LII_I", "LII_L", "LLI_L", "LLI_I", "LILI_I", "LIIL_L",
 124                 "LIILL_L", "LIILL_I", "LIIL_I", "LILIL_I", "LILILL_I",
 125                 "LILII_I", "LI3_I", "LI3L_I", "LI3LL_I", "LI3_L", "LI4_I"),
 126             DMH_INVOKE_STATIC, List.of("II_I", "IL_I", "ILIL_I", "ILII_I",
 127                 "_I", "_L", "_V", "D_L", "F_L", "I_I", "II_L", "LI_L",
 128                 "L_V", "L_L", "LL_L", "L3_L", "L4_L", "L5_L", "L6_L",
 129                 "L7_L", "L8_L", "L9_L", "L9I_L", "L9II_L", "L9IIL_L",
 130                 "L10_L", "L11_L", "L12_L", "L13_L", "L13I_L", "L13II_L")
 131         );
 132     }
 133 
 134     // Map from DirectMethodHandle method type to internal ID
 135     private static final Map<String, Integer> DMH_METHOD_TYPE_MAP =
 136             Map.of(
 137                 DMH_INVOKE_VIRTUAL,     0,
 138                 DMH_INVOKE_STATIC,      1,
 139                 DMH_INVOKE_SPECIAL,     2,
 140                 DMH_NEW_INVOKE_SPECIAL, 3,
 141                 DMH_INVOKE_INTERFACE,   4,
 142                 DMH_INVOKE_STATIC_INIT, 5
 143             );
 144 
 145     @Override
 146     public void configure(Map<String, String> config) {
 147         String mainArgument = config.get(NAME);
 148 
 149         // Enable by default
 150         boolean bmhEnabled = true;
 151         boolean dmhEnabled = true;
 152         if (mainArgument != null) {
 153             List<String> args = Arrays.asList(mainArgument.split(","));
 154             if (!args.contains(BMH_PARAM)) {
 155                 bmhEnabled = false;
 156             }
 157             if (!args.contains(DMH_PARAM)) {
 158                 dmhEnabled = false;
 159             }
 160         }
 161 
 162         if (!bmhEnabled) {
 163             speciesTypes = List.of();
 164         } else {
 165             String args = config.get(BMH_SPECIES_PARAM);
 166             List<String> bmhSpecies;
 167             if (args != null && !args.isEmpty()) {
 168                 bmhSpecies = Arrays.stream(args.split(","))
 169                     .map(String::trim)
 170                     .filter(s -> !s.isEmpty())
 171                     .collect(Collectors.toList());
 172             } else {
 173                 bmhSpecies = defaultSpecies();
 174             }
 175 
 176             // Expand BMH species signatures
 177             speciesTypes = bmhSpecies.stream()
 178                     .map(type -> expandSignature(type))
 179                     .collect(Collectors.toList());
 180         }
 181 
 182         // DirectMethodHandles
 183         if (!dmhEnabled) {
 184             dmhMethods = Map.of();
 185         } else {
 186             dmhMethods = new HashMap<>();
 187             for (String dmhParam : DMH_METHOD_TYPE_MAP.keySet()) {
 188                 String args = config.get(dmhParam);
 189                 if (args != null && !args.isEmpty()) {
 190                     List<String> dmhMethodTypes = Arrays.stream(args.split(","))
 191                             .map(String::trim)
 192                             .filter(s -> !s.isEmpty())
 193                             .collect(Collectors.toList());
 194                     dmhMethods.put(dmhParam, dmhMethodTypes);
 195                     // Validation check
 196                     for (String type : dmhMethodTypes) {
 197                         String[] typeParts = type.split("_");
 198                         // check return type (second part)
 199                         if (typeParts.length != 2 || typeParts[1].length() != 1
 200                                 || "LJIFDV".indexOf(typeParts[1].charAt(0)) == -1) {
 201                             throw new PluginException(
 202                                     "Method type signature must be of form [LJIFD]*_[LJIFDV]");
 203                         }
 204                         // expand and check arguments (first part)
 205                         expandSignature(typeParts[0]);
 206                     }
 207                 }
 208             }
 209             if (dmhMethods.isEmpty()) {
 210                 dmhMethods = defaultDMHMethods();
 211             }
 212         }
 213     }
 214 
 215     private static void requireBasicType(char c) {
 216         if ("LIJFD".indexOf(c) < 0) {
 217             throw new PluginException(
 218                     "Character " + c + " must correspond to a basic field type: LIJFD");
 219         }
 220     }
 221 
 222     @Override
 223     public ResourcePool transform(ResourcePool in, ResourcePoolBuilder out) {
 224         // Copy all but DMH_ENTRY to out
 225         in.transformAndCopy(entry -> entry.path().equals(DMH_ENTRY) ? null : entry, out);








 226         speciesTypes.forEach(types -> generateBMHClass(types, out));
 227         generateDMHClass(out);
 228         return out.build();
 229     }
 230 
 231     @SuppressWarnings("unchecked")
 232     private void generateBMHClass(String types, ResourcePoolBuilder out) {
 233         try {
 234             // Generate class
 235             Map.Entry<String, byte[]> result =
 236                     JLIA.generateConcreteBMHClassBytes(types);
 237             String className = result.getKey();
 238             byte[] bytes = result.getValue();
 239 
 240             // Add class to pool
 241             ResourcePoolEntry ndata = ResourcePoolEntry.create(
 242                     "/java.base/" + className + ".class",
 243                     bytes);
 244             out.add(ndata);
 245         } catch (Exception ex) {
 246             throw new PluginException(ex);
 247         }
 248     }
 249 
 250     private void generateDMHClass(ResourcePoolBuilder out) {
 251         int count = 0;
 252         for (List<String> entry : dmhMethods.values()) {
 253             count += entry.size();
 254         }
 255         MethodType[] methodTypes = new MethodType[count];
 256         int[] dmhTypes = new int[count];
 257         int index = 0;
 258         for (Map.Entry<String, List<String>> entry : dmhMethods.entrySet()) {
 259             String dmhType = entry.getKey();
 260             for (String type : entry.getValue()) {
 261                 methodTypes[index] = asMethodType(type);
 262                 dmhTypes[index] = DMH_METHOD_TYPE_MAP.get(dmhType);
 263                 index++;
 264             }
 265         }
 266         try {
 267             byte[] bytes =
 268                     JLIA.generateDMHClassBytes(DMH, methodTypes, dmhTypes);
 269             ResourcePoolEntry ndata = ResourcePoolEntry.create(DMH_ENTRY, bytes);






 270             out.add(ndata);
 271         } catch (Exception ex) {
 272             throw new PluginException(ex);
 273         }
 274     }
 275     private static final String DMH_ENTRY = "/java.base/" + DMH + ".class";



 276 
 277     // Convert LL -> LL, L3 -> LLL
 278     private static String expandSignature(String signature) {
 279         StringBuilder sb = new StringBuilder();
 280         char last = 'X';
 281         int count = 0;
 282         for (int i = 0; i < signature.length(); i++) {
 283             char c = signature.charAt(i);
 284             if (c >= '0' && c <= '9') {
 285                 count *= 10;
 286                 count += (c - '0');
 287             } else {
 288                 requireBasicType(c);
 289                 for (int j = 1; j < count; j++) {
 290                     sb.append(last);
 291                 }
 292                 sb.append(c);
 293                 last = c;
 294                 count = 0;
 295             }
 296         }
 297 
 298         // ended with a number, e.g., "L2": append last char count - 1 times
 299         if (count > 1) {
 300             requireBasicType(last);
 301             for (int j = 1; j < count; j++) {
 302                 sb.append(last);
 303             }
 304         }
 305         return sb.toString();
 306     }
 307 
 308     private static MethodType asMethodType(String basicSignatureString) {
 309         String[] parts = basicSignatureString.split("_");
 310         assert(parts.length == 2);
 311         assert(parts[1].length() == 1);
 312         String parameters = expandSignature(parts[0]);
 313         Class<?> rtype = primitiveType(parts[1].charAt(0));
 314         Class<?>[] ptypes = new Class<?>[parameters.length()];



 315         for (int i = 0; i < ptypes.length; i++) {
 316             ptypes[i] = primitiveType(parameters.charAt(i));
 317         }
 318         return MethodType.methodType(rtype, ptypes);
 319     }

 320 
 321     private static Class<?> primitiveType(char c) {
 322         switch (c) {
 323             case 'F':
 324                 return float.class;
 325             case 'D':
 326                 return double.class;
 327             case 'I':
 328                 return int.class;
 329             case 'L':
 330                 return Object.class;
 331             case 'J':
 332                 return long.class;
 333             case 'V':
 334                 return void.class;
 335             case 'Z':
 336             case 'B':
 337             case 'S':
 338             case 'C':
 339                 throw new IllegalArgumentException("Not a valid primitive: " + c +
 340                         " (use I instead)");
 341             default:
 342                 throw new IllegalArgumentException("Not a primitive: " + c);
 343         }
 344     }
 345 }
--- EOF ---