jaroslav@1646
|
1 |
/*
|
jaroslav@1646
|
2 |
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
|
jaroslav@1646
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
jaroslav@1646
|
4 |
*
|
jaroslav@1646
|
5 |
* This code is free software; you can redistribute it and/or modify it
|
jaroslav@1646
|
6 |
* under the terms of the GNU General Public License version 2 only, as
|
jaroslav@1646
|
7 |
* published by the Free Software Foundation. Oracle designates this
|
jaroslav@1646
|
8 |
* particular file as subject to the "Classpath" exception as provided
|
jaroslav@1646
|
9 |
* by Oracle in the LICENSE file that accompanied this code.
|
jaroslav@1646
|
10 |
*
|
jaroslav@1646
|
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
jaroslav@1646
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
jaroslav@1646
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
jaroslav@1646
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that
|
jaroslav@1646
|
15 |
* accompanied this code).
|
jaroslav@1646
|
16 |
*
|
jaroslav@1646
|
17 |
* You should have received a copy of the GNU General Public License version
|
jaroslav@1646
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
jaroslav@1646
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
jaroslav@1646
|
20 |
*
|
jaroslav@1646
|
21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
jaroslav@1646
|
22 |
* or visit www.oracle.com if you need additional information or have any
|
jaroslav@1646
|
23 |
* questions.
|
jaroslav@1646
|
24 |
*/
|
jaroslav@1646
|
25 |
|
jaroslav@1646
|
26 |
package java.lang.invoke;
|
jaroslav@1646
|
27 |
|
jaroslav@1646
|
28 |
import sun.invoke.util.VerifyAccess;
|
jaroslav@1646
|
29 |
import java.lang.invoke.LambdaForm.Name;
|
jaroslav@1646
|
30 |
import java.lang.invoke.MethodHandles.Lookup;
|
jaroslav@1646
|
31 |
|
jaroslav@1646
|
32 |
import sun.invoke.util.Wrapper;
|
jaroslav@1646
|
33 |
|
jaroslav@1646
|
34 |
import java.io.*;
|
jaroslav@1646
|
35 |
import java.util.*;
|
jaroslav@1646
|
36 |
|
jaroslav@1646
|
37 |
import jdk.internal.org.objectweb.asm.*;
|
jaroslav@1646
|
38 |
|
jaroslav@1646
|
39 |
import java.lang.reflect.*;
|
jaroslav@1646
|
40 |
import static java.lang.invoke.MethodHandleStatics.*;
|
jaroslav@1646
|
41 |
import static java.lang.invoke.MethodHandleNatives.Constants.*;
|
jaroslav@1646
|
42 |
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
|
jaroslav@1646
|
43 |
import sun.invoke.util.ValueConversions;
|
jaroslav@1646
|
44 |
import sun.invoke.util.VerifyType;
|
jaroslav@1646
|
45 |
|
jaroslav@1646
|
46 |
/**
|
jaroslav@1646
|
47 |
* Code generation backend for LambdaForm.
|
jaroslav@1646
|
48 |
* <p>
|
jaroslav@1646
|
49 |
* @author John Rose, JSR 292 EG
|
jaroslav@1646
|
50 |
*/
|
jaroslav@1646
|
51 |
class InvokerBytecodeGenerator {
|
jaroslav@1646
|
52 |
/** Define class names for convenience. */
|
jaroslav@1646
|
53 |
private static final String MH = "java/lang/invoke/MethodHandle";
|
jaroslav@1646
|
54 |
private static final String BMH = "java/lang/invoke/BoundMethodHandle";
|
jaroslav@1646
|
55 |
private static final String LF = "java/lang/invoke/LambdaForm";
|
jaroslav@1646
|
56 |
private static final String LFN = "java/lang/invoke/LambdaForm$Name";
|
jaroslav@1646
|
57 |
private static final String CLS = "java/lang/Class";
|
jaroslav@1646
|
58 |
private static final String OBJ = "java/lang/Object";
|
jaroslav@1646
|
59 |
private static final String OBJARY = "[Ljava/lang/Object;";
|
jaroslav@1646
|
60 |
|
jaroslav@1646
|
61 |
private static final String LF_SIG = "L" + LF + ";";
|
jaroslav@1646
|
62 |
private static final String LFN_SIG = "L" + LFN + ";";
|
jaroslav@1646
|
63 |
private static final String LL_SIG = "(L" + OBJ + ";)L" + OBJ + ";";
|
jaroslav@1646
|
64 |
|
jaroslav@1646
|
65 |
/** Name of its super class*/
|
jaroslav@1646
|
66 |
private static final String superName = LF;
|
jaroslav@1646
|
67 |
|
jaroslav@1646
|
68 |
/** Name of new class */
|
jaroslav@1646
|
69 |
private final String className;
|
jaroslav@1646
|
70 |
|
jaroslav@1646
|
71 |
/** Name of the source file (for stack trace printing). */
|
jaroslav@1646
|
72 |
private final String sourceFile;
|
jaroslav@1646
|
73 |
|
jaroslav@1646
|
74 |
private final LambdaForm lambdaForm;
|
jaroslav@1646
|
75 |
private final String invokerName;
|
jaroslav@1646
|
76 |
private final MethodType invokerType;
|
jaroslav@1646
|
77 |
private final int[] localsMap;
|
jaroslav@1646
|
78 |
|
jaroslav@1646
|
79 |
/** ASM bytecode generation. */
|
jaroslav@1646
|
80 |
private ClassWriter cw;
|
jaroslav@1646
|
81 |
private MethodVisitor mv;
|
jaroslav@1646
|
82 |
|
jaroslav@1646
|
83 |
private static final MemberName.Factory MEMBERNAME_FACTORY = MemberName.getFactory();
|
jaroslav@1646
|
84 |
private static final Class<?> HOST_CLASS = LambdaForm.class;
|
jaroslav@1646
|
85 |
|
jaroslav@1646
|
86 |
private InvokerBytecodeGenerator(LambdaForm lambdaForm, int localsMapSize,
|
jaroslav@1646
|
87 |
String className, String invokerName, MethodType invokerType) {
|
jaroslav@1646
|
88 |
if (invokerName.contains(".")) {
|
jaroslav@1646
|
89 |
int p = invokerName.indexOf(".");
|
jaroslav@1646
|
90 |
className = invokerName.substring(0, p);
|
jaroslav@1646
|
91 |
invokerName = invokerName.substring(p+1);
|
jaroslav@1646
|
92 |
}
|
jaroslav@1646
|
93 |
if (DUMP_CLASS_FILES) {
|
jaroslav@1646
|
94 |
className = makeDumpableClassName(className);
|
jaroslav@1646
|
95 |
}
|
jaroslav@1646
|
96 |
this.className = superName + "$" + className;
|
jaroslav@1646
|
97 |
this.sourceFile = "LambdaForm$" + className;
|
jaroslav@1646
|
98 |
this.lambdaForm = lambdaForm;
|
jaroslav@1646
|
99 |
this.invokerName = invokerName;
|
jaroslav@1646
|
100 |
this.invokerType = invokerType;
|
jaroslav@1646
|
101 |
this.localsMap = new int[localsMapSize];
|
jaroslav@1646
|
102 |
}
|
jaroslav@1646
|
103 |
|
jaroslav@1646
|
104 |
private InvokerBytecodeGenerator(String className, String invokerName, MethodType invokerType) {
|
jaroslav@1646
|
105 |
this(null, invokerType.parameterCount(),
|
jaroslav@1646
|
106 |
className, invokerName, invokerType);
|
jaroslav@1646
|
107 |
// Create an array to map name indexes to locals indexes.
|
jaroslav@1646
|
108 |
for (int i = 0; i < localsMap.length; i++) {
|
jaroslav@1646
|
109 |
localsMap[i] = invokerType.parameterSlotCount() - invokerType.parameterSlotDepth(i);
|
jaroslav@1646
|
110 |
}
|
jaroslav@1646
|
111 |
}
|
jaroslav@1646
|
112 |
|
jaroslav@1646
|
113 |
private InvokerBytecodeGenerator(String className, LambdaForm form, MethodType invokerType) {
|
jaroslav@1646
|
114 |
this(form, form.names.length,
|
jaroslav@1646
|
115 |
className, form.debugName, invokerType);
|
jaroslav@1646
|
116 |
// Create an array to map name indexes to locals indexes.
|
jaroslav@1646
|
117 |
Name[] names = form.names;
|
jaroslav@1646
|
118 |
for (int i = 0, index = 0; i < localsMap.length; i++) {
|
jaroslav@1646
|
119 |
localsMap[i] = index;
|
jaroslav@1646
|
120 |
index += Wrapper.forBasicType(names[i].type).stackSlots();
|
jaroslav@1646
|
121 |
}
|
jaroslav@1646
|
122 |
}
|
jaroslav@1646
|
123 |
|
jaroslav@1646
|
124 |
|
jaroslav@1646
|
125 |
/** instance counters for dumped classes */
|
jaroslav@1646
|
126 |
private final static HashMap<String,Integer> DUMP_CLASS_FILES_COUNTERS;
|
jaroslav@1646
|
127 |
/** debugging flag for saving generated class files */
|
jaroslav@1646
|
128 |
private final static File DUMP_CLASS_FILES_DIR;
|
jaroslav@1646
|
129 |
|
jaroslav@1646
|
130 |
static {
|
jaroslav@1646
|
131 |
if (DUMP_CLASS_FILES) {
|
jaroslav@1646
|
132 |
DUMP_CLASS_FILES_COUNTERS = new HashMap<>();
|
jaroslav@1646
|
133 |
try {
|
jaroslav@1646
|
134 |
File dumpDir = new File("DUMP_CLASS_FILES");
|
jaroslav@1646
|
135 |
if (!dumpDir.exists()) {
|
jaroslav@1646
|
136 |
dumpDir.mkdirs();
|
jaroslav@1646
|
137 |
}
|
jaroslav@1646
|
138 |
DUMP_CLASS_FILES_DIR = dumpDir;
|
jaroslav@1646
|
139 |
System.out.println("Dumping class files to "+DUMP_CLASS_FILES_DIR+"/...");
|
jaroslav@1646
|
140 |
} catch (Exception e) {
|
jaroslav@1646
|
141 |
throw newInternalError(e);
|
jaroslav@1646
|
142 |
}
|
jaroslav@1646
|
143 |
} else {
|
jaroslav@1646
|
144 |
DUMP_CLASS_FILES_COUNTERS = null;
|
jaroslav@1646
|
145 |
DUMP_CLASS_FILES_DIR = null;
|
jaroslav@1646
|
146 |
}
|
jaroslav@1646
|
147 |
}
|
jaroslav@1646
|
148 |
|
jaroslav@1646
|
149 |
static void maybeDump(final String className, final byte[] classFile) {
|
jaroslav@1646
|
150 |
if (DUMP_CLASS_FILES) {
|
jaroslav@1646
|
151 |
System.out.println("dump: " + className);
|
jaroslav@1646
|
152 |
java.security.AccessController.doPrivileged(
|
jaroslav@1646
|
153 |
new java.security.PrivilegedAction<Void>() {
|
jaroslav@1646
|
154 |
public Void run() {
|
jaroslav@1646
|
155 |
try {
|
jaroslav@1646
|
156 |
String dumpName = className;
|
jaroslav@1646
|
157 |
//dumpName = dumpName.replace('/', '-');
|
jaroslav@1646
|
158 |
File dumpFile = new File(DUMP_CLASS_FILES_DIR, dumpName+".class");
|
jaroslav@1646
|
159 |
dumpFile.getParentFile().mkdirs();
|
jaroslav@1646
|
160 |
FileOutputStream file = new FileOutputStream(dumpFile);
|
jaroslav@1646
|
161 |
file.write(classFile);
|
jaroslav@1646
|
162 |
file.close();
|
jaroslav@1646
|
163 |
return null;
|
jaroslav@1646
|
164 |
} catch (IOException ex) {
|
jaroslav@1646
|
165 |
throw newInternalError(ex);
|
jaroslav@1646
|
166 |
}
|
jaroslav@1646
|
167 |
}
|
jaroslav@1646
|
168 |
});
|
jaroslav@1646
|
169 |
}
|
jaroslav@1646
|
170 |
|
jaroslav@1646
|
171 |
}
|
jaroslav@1646
|
172 |
|
jaroslav@1646
|
173 |
private static String makeDumpableClassName(String className) {
|
jaroslav@1646
|
174 |
Integer ctr;
|
jaroslav@1646
|
175 |
synchronized (DUMP_CLASS_FILES_COUNTERS) {
|
jaroslav@1646
|
176 |
ctr = DUMP_CLASS_FILES_COUNTERS.get(className);
|
jaroslav@1646
|
177 |
if (ctr == null) ctr = 0;
|
jaroslav@1646
|
178 |
DUMP_CLASS_FILES_COUNTERS.put(className, ctr+1);
|
jaroslav@1646
|
179 |
}
|
jaroslav@1646
|
180 |
String sfx = ctr.toString();
|
jaroslav@1646
|
181 |
while (sfx.length() < 3)
|
jaroslav@1646
|
182 |
sfx = "0"+sfx;
|
jaroslav@1646
|
183 |
className += sfx;
|
jaroslav@1646
|
184 |
return className;
|
jaroslav@1646
|
185 |
}
|
jaroslav@1646
|
186 |
|
jaroslav@1646
|
187 |
class CpPatch {
|
jaroslav@1646
|
188 |
final int index;
|
jaroslav@1646
|
189 |
final String placeholder;
|
jaroslav@1646
|
190 |
final Object value;
|
jaroslav@1646
|
191 |
CpPatch(int index, String placeholder, Object value) {
|
jaroslav@1646
|
192 |
this.index = index;
|
jaroslav@1646
|
193 |
this.placeholder = placeholder;
|
jaroslav@1646
|
194 |
this.value = value;
|
jaroslav@1646
|
195 |
}
|
jaroslav@1646
|
196 |
public String toString() {
|
jaroslav@1646
|
197 |
return "CpPatch/index="+index+",placeholder="+placeholder+",value="+value;
|
jaroslav@1646
|
198 |
}
|
jaroslav@1646
|
199 |
}
|
jaroslav@1646
|
200 |
|
jaroslav@1646
|
201 |
Map<Object, CpPatch> cpPatches = new HashMap<>();
|
jaroslav@1646
|
202 |
|
jaroslav@1646
|
203 |
int cph = 0; // for counting constant placeholders
|
jaroslav@1646
|
204 |
|
jaroslav@1646
|
205 |
String constantPlaceholder(Object arg) {
|
jaroslav@1646
|
206 |
String cpPlaceholder = "CONSTANT_PLACEHOLDER_" + cph++;
|
jaroslav@1646
|
207 |
if (DUMP_CLASS_FILES) cpPlaceholder += " <<" + arg.toString() + ">>"; // debugging aid
|
jaroslav@1646
|
208 |
if (cpPatches.containsKey(cpPlaceholder)) {
|
jaroslav@1646
|
209 |
throw new InternalError("observed CP placeholder twice: " + cpPlaceholder);
|
jaroslav@1646
|
210 |
}
|
jaroslav@1646
|
211 |
// insert placeholder in CP and remember the patch
|
jaroslav@1646
|
212 |
int index = cw.newConst((Object) cpPlaceholder); // TODO check if aready in the constant pool
|
jaroslav@1646
|
213 |
cpPatches.put(cpPlaceholder, new CpPatch(index, cpPlaceholder, arg));
|
jaroslav@1646
|
214 |
return cpPlaceholder;
|
jaroslav@1646
|
215 |
}
|
jaroslav@1646
|
216 |
|
jaroslav@1646
|
217 |
Object[] cpPatches(byte[] classFile) {
|
jaroslav@1646
|
218 |
int size = getConstantPoolSize(classFile);
|
jaroslav@1646
|
219 |
Object[] res = new Object[size];
|
jaroslav@1646
|
220 |
for (CpPatch p : cpPatches.values()) {
|
jaroslav@1646
|
221 |
if (p.index >= size)
|
jaroslav@1646
|
222 |
throw new InternalError("in cpool["+size+"]: "+p+"\n"+Arrays.toString(Arrays.copyOf(classFile, 20)));
|
jaroslav@1646
|
223 |
res[p.index] = p.value;
|
jaroslav@1646
|
224 |
}
|
jaroslav@1646
|
225 |
return res;
|
jaroslav@1646
|
226 |
}
|
jaroslav@1646
|
227 |
|
jaroslav@1646
|
228 |
/**
|
jaroslav@1646
|
229 |
* Extract the number of constant pool entries from a given class file.
|
jaroslav@1646
|
230 |
*
|
jaroslav@1646
|
231 |
* @param classFile the bytes of the class file in question.
|
jaroslav@1646
|
232 |
* @return the number of entries in the constant pool.
|
jaroslav@1646
|
233 |
*/
|
jaroslav@1646
|
234 |
private static int getConstantPoolSize(byte[] classFile) {
|
jaroslav@1646
|
235 |
// The first few bytes:
|
jaroslav@1646
|
236 |
// u4 magic;
|
jaroslav@1646
|
237 |
// u2 minor_version;
|
jaroslav@1646
|
238 |
// u2 major_version;
|
jaroslav@1646
|
239 |
// u2 constant_pool_count;
|
jaroslav@1646
|
240 |
return ((classFile[8] & 0xFF) << 8) | (classFile[9] & 0xFF);
|
jaroslav@1646
|
241 |
}
|
jaroslav@1646
|
242 |
|
jaroslav@1646
|
243 |
/**
|
jaroslav@1646
|
244 |
* Extract the MemberName of a newly-defined method.
|
jaroslav@1646
|
245 |
*/
|
jaroslav@1646
|
246 |
private MemberName loadMethod(byte[] classFile) {
|
jaroslav@1646
|
247 |
Class<?> invokerClass = loadAndInitializeInvokerClass(classFile, cpPatches(classFile));
|
jaroslav@1646
|
248 |
return resolveInvokerMember(invokerClass, invokerName, invokerType);
|
jaroslav@1646
|
249 |
}
|
jaroslav@1646
|
250 |
|
jaroslav@1646
|
251 |
/**
|
jaroslav@1646
|
252 |
* Define a given class as anonymous class in the runtime system.
|
jaroslav@1646
|
253 |
*/
|
jaroslav@1646
|
254 |
private static Class<?> loadAndInitializeInvokerClass(byte[] classBytes, Object[] patches) {
|
jaroslav@1646
|
255 |
Class<?> invokerClass = UNSAFE.defineAnonymousClass(HOST_CLASS, classBytes, patches);
|
jaroslav@1646
|
256 |
UNSAFE.ensureClassInitialized(invokerClass); // Make sure the class is initialized; VM might complain.
|
jaroslav@1646
|
257 |
return invokerClass;
|
jaroslav@1646
|
258 |
}
|
jaroslav@1646
|
259 |
|
jaroslav@1646
|
260 |
private static MemberName resolveInvokerMember(Class<?> invokerClass, String name, MethodType type) {
|
jaroslav@1646
|
261 |
MemberName member = new MemberName(invokerClass, name, type, REF_invokeStatic);
|
jaroslav@1646
|
262 |
//System.out.println("resolveInvokerMember => "+member);
|
jaroslav@1646
|
263 |
//for (Method m : invokerClass.getDeclaredMethods()) System.out.println(" "+m);
|
jaroslav@1646
|
264 |
try {
|
jaroslav@1646
|
265 |
member = MEMBERNAME_FACTORY.resolveOrFail(REF_invokeStatic, member, HOST_CLASS, ReflectiveOperationException.class);
|
jaroslav@1646
|
266 |
} catch (ReflectiveOperationException e) {
|
jaroslav@1646
|
267 |
throw newInternalError(e);
|
jaroslav@1646
|
268 |
}
|
jaroslav@1646
|
269 |
//System.out.println("resolveInvokerMember => "+member);
|
jaroslav@1646
|
270 |
return member;
|
jaroslav@1646
|
271 |
}
|
jaroslav@1646
|
272 |
|
jaroslav@1646
|
273 |
/**
|
jaroslav@1646
|
274 |
* Set up class file generation.
|
jaroslav@1646
|
275 |
*/
|
jaroslav@1646
|
276 |
private void classFilePrologue() {
|
jaroslav@1646
|
277 |
cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);
|
jaroslav@1646
|
278 |
cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, className, null, superName, null);
|
jaroslav@1646
|
279 |
cw.visitSource(sourceFile, null);
|
jaroslav@1646
|
280 |
|
jaroslav@1646
|
281 |
String invokerDesc = invokerType.toMethodDescriptorString();
|
jaroslav@1646
|
282 |
mv = cw.visitMethod(Opcodes.ACC_STATIC, invokerName, invokerDesc, null, null);
|
jaroslav@1646
|
283 |
}
|
jaroslav@1646
|
284 |
|
jaroslav@1646
|
285 |
/**
|
jaroslav@1646
|
286 |
* Tear down class file generation.
|
jaroslav@1646
|
287 |
*/
|
jaroslav@1646
|
288 |
private void classFileEpilogue() {
|
jaroslav@1646
|
289 |
mv.visitMaxs(0, 0);
|
jaroslav@1646
|
290 |
mv.visitEnd();
|
jaroslav@1646
|
291 |
}
|
jaroslav@1646
|
292 |
|
jaroslav@1646
|
293 |
/*
|
jaroslav@1646
|
294 |
* Low-level emit helpers.
|
jaroslav@1646
|
295 |
*/
|
jaroslav@1646
|
296 |
private void emitConst(Object con) {
|
jaroslav@1646
|
297 |
if (con == null) {
|
jaroslav@1646
|
298 |
mv.visitInsn(Opcodes.ACONST_NULL);
|
jaroslav@1646
|
299 |
return;
|
jaroslav@1646
|
300 |
}
|
jaroslav@1646
|
301 |
if (con instanceof Integer) {
|
jaroslav@1646
|
302 |
emitIconstInsn((int) con);
|
jaroslav@1646
|
303 |
return;
|
jaroslav@1646
|
304 |
}
|
jaroslav@1646
|
305 |
if (con instanceof Long) {
|
jaroslav@1646
|
306 |
long x = (long) con;
|
jaroslav@1646
|
307 |
if (x == (short) x) {
|
jaroslav@1646
|
308 |
emitIconstInsn((int) x);
|
jaroslav@1646
|
309 |
mv.visitInsn(Opcodes.I2L);
|
jaroslav@1646
|
310 |
return;
|
jaroslav@1646
|
311 |
}
|
jaroslav@1646
|
312 |
}
|
jaroslav@1646
|
313 |
if (con instanceof Float) {
|
jaroslav@1646
|
314 |
float x = (float) con;
|
jaroslav@1646
|
315 |
if (x == (short) x) {
|
jaroslav@1646
|
316 |
emitIconstInsn((int) x);
|
jaroslav@1646
|
317 |
mv.visitInsn(Opcodes.I2F);
|
jaroslav@1646
|
318 |
return;
|
jaroslav@1646
|
319 |
}
|
jaroslav@1646
|
320 |
}
|
jaroslav@1646
|
321 |
if (con instanceof Double) {
|
jaroslav@1646
|
322 |
double x = (double) con;
|
jaroslav@1646
|
323 |
if (x == (short) x) {
|
jaroslav@1646
|
324 |
emitIconstInsn((int) x);
|
jaroslav@1646
|
325 |
mv.visitInsn(Opcodes.I2D);
|
jaroslav@1646
|
326 |
return;
|
jaroslav@1646
|
327 |
}
|
jaroslav@1646
|
328 |
}
|
jaroslav@1646
|
329 |
if (con instanceof Boolean) {
|
jaroslav@1646
|
330 |
emitIconstInsn((boolean) con ? 1 : 0);
|
jaroslav@1646
|
331 |
return;
|
jaroslav@1646
|
332 |
}
|
jaroslav@1646
|
333 |
// fall through:
|
jaroslav@1646
|
334 |
mv.visitLdcInsn(con);
|
jaroslav@1646
|
335 |
}
|
jaroslav@1646
|
336 |
|
jaroslav@1646
|
337 |
private void emitIconstInsn(int i) {
|
jaroslav@1646
|
338 |
int opcode;
|
jaroslav@1646
|
339 |
switch (i) {
|
jaroslav@1646
|
340 |
case 0: opcode = Opcodes.ICONST_0; break;
|
jaroslav@1646
|
341 |
case 1: opcode = Opcodes.ICONST_1; break;
|
jaroslav@1646
|
342 |
case 2: opcode = Opcodes.ICONST_2; break;
|
jaroslav@1646
|
343 |
case 3: opcode = Opcodes.ICONST_3; break;
|
jaroslav@1646
|
344 |
case 4: opcode = Opcodes.ICONST_4; break;
|
jaroslav@1646
|
345 |
case 5: opcode = Opcodes.ICONST_5; break;
|
jaroslav@1646
|
346 |
default:
|
jaroslav@1646
|
347 |
if (i == (byte) i) {
|
jaroslav@1646
|
348 |
mv.visitIntInsn(Opcodes.BIPUSH, i & 0xFF);
|
jaroslav@1646
|
349 |
} else if (i == (short) i) {
|
jaroslav@1646
|
350 |
mv.visitIntInsn(Opcodes.SIPUSH, (char) i);
|
jaroslav@1646
|
351 |
} else {
|
jaroslav@1646
|
352 |
mv.visitLdcInsn(i);
|
jaroslav@1646
|
353 |
}
|
jaroslav@1646
|
354 |
return;
|
jaroslav@1646
|
355 |
}
|
jaroslav@1646
|
356 |
mv.visitInsn(opcode);
|
jaroslav@1646
|
357 |
}
|
jaroslav@1646
|
358 |
|
jaroslav@1646
|
359 |
/*
|
jaroslav@1646
|
360 |
* NOTE: These load/store methods use the localsMap to find the correct index!
|
jaroslav@1646
|
361 |
*/
|
jaroslav@1646
|
362 |
private void emitLoadInsn(char type, int index) {
|
jaroslav@1646
|
363 |
int opcode;
|
jaroslav@1646
|
364 |
switch (type) {
|
jaroslav@1646
|
365 |
case 'I': opcode = Opcodes.ILOAD; break;
|
jaroslav@1646
|
366 |
case 'J': opcode = Opcodes.LLOAD; break;
|
jaroslav@1646
|
367 |
case 'F': opcode = Opcodes.FLOAD; break;
|
jaroslav@1646
|
368 |
case 'D': opcode = Opcodes.DLOAD; break;
|
jaroslav@1646
|
369 |
case 'L': opcode = Opcodes.ALOAD; break;
|
jaroslav@1646
|
370 |
default:
|
jaroslav@1646
|
371 |
throw new InternalError("unknown type: " + type);
|
jaroslav@1646
|
372 |
}
|
jaroslav@1646
|
373 |
mv.visitVarInsn(opcode, localsMap[index]);
|
jaroslav@1646
|
374 |
}
|
jaroslav@1646
|
375 |
private void emitAloadInsn(int index) {
|
jaroslav@1646
|
376 |
emitLoadInsn('L', index);
|
jaroslav@1646
|
377 |
}
|
jaroslav@1646
|
378 |
|
jaroslav@1646
|
379 |
private void emitStoreInsn(char type, int index) {
|
jaroslav@1646
|
380 |
int opcode;
|
jaroslav@1646
|
381 |
switch (type) {
|
jaroslav@1646
|
382 |
case 'I': opcode = Opcodes.ISTORE; break;
|
jaroslav@1646
|
383 |
case 'J': opcode = Opcodes.LSTORE; break;
|
jaroslav@1646
|
384 |
case 'F': opcode = Opcodes.FSTORE; break;
|
jaroslav@1646
|
385 |
case 'D': opcode = Opcodes.DSTORE; break;
|
jaroslav@1646
|
386 |
case 'L': opcode = Opcodes.ASTORE; break;
|
jaroslav@1646
|
387 |
default:
|
jaroslav@1646
|
388 |
throw new InternalError("unknown type: " + type);
|
jaroslav@1646
|
389 |
}
|
jaroslav@1646
|
390 |
mv.visitVarInsn(opcode, localsMap[index]);
|
jaroslav@1646
|
391 |
}
|
jaroslav@1646
|
392 |
private void emitAstoreInsn(int index) {
|
jaroslav@1646
|
393 |
emitStoreInsn('L', index);
|
jaroslav@1646
|
394 |
}
|
jaroslav@1646
|
395 |
|
jaroslav@1646
|
396 |
/**
|
jaroslav@1646
|
397 |
* Emit a boxing call.
|
jaroslav@1646
|
398 |
*
|
jaroslav@1646
|
399 |
* @param type primitive type class to box.
|
jaroslav@1646
|
400 |
*/
|
jaroslav@1646
|
401 |
private void emitBoxing(Class<?> type) {
|
jaroslav@1646
|
402 |
Wrapper wrapper = Wrapper.forPrimitiveType(type);
|
jaroslav@1646
|
403 |
String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
|
jaroslav@1646
|
404 |
String name = "valueOf";
|
jaroslav@1646
|
405 |
String desc = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
|
jaroslav@1646
|
406 |
mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc);
|
jaroslav@1646
|
407 |
}
|
jaroslav@1646
|
408 |
|
jaroslav@1646
|
409 |
/**
|
jaroslav@1646
|
410 |
* Emit an unboxing call (plus preceding checkcast).
|
jaroslav@1646
|
411 |
*
|
jaroslav@1646
|
412 |
* @param type wrapper type class to unbox.
|
jaroslav@1646
|
413 |
*/
|
jaroslav@1646
|
414 |
private void emitUnboxing(Class<?> type) {
|
jaroslav@1646
|
415 |
Wrapper wrapper = Wrapper.forWrapperType(type);
|
jaroslav@1646
|
416 |
String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
|
jaroslav@1646
|
417 |
String name = wrapper.primitiveSimpleName() + "Value";
|
jaroslav@1646
|
418 |
String desc = "()" + wrapper.basicTypeChar();
|
jaroslav@1646
|
419 |
mv.visitTypeInsn(Opcodes.CHECKCAST, owner);
|
jaroslav@1646
|
420 |
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc);
|
jaroslav@1646
|
421 |
}
|
jaroslav@1646
|
422 |
|
jaroslav@1646
|
423 |
/**
|
jaroslav@1646
|
424 |
* Emit an implicit conversion.
|
jaroslav@1646
|
425 |
*
|
jaroslav@1646
|
426 |
* @param ptype type of value present on stack
|
jaroslav@1646
|
427 |
* @param pclass type of value required on stack
|
jaroslav@1646
|
428 |
*/
|
jaroslav@1646
|
429 |
private void emitImplicitConversion(char ptype, Class<?> pclass) {
|
jaroslav@1646
|
430 |
switch (ptype) {
|
jaroslav@1646
|
431 |
case 'L':
|
jaroslav@1646
|
432 |
if (VerifyType.isNullConversion(Object.class, pclass))
|
jaroslav@1646
|
433 |
return;
|
jaroslav@1646
|
434 |
if (isStaticallyNameable(pclass)) {
|
jaroslav@1646
|
435 |
mv.visitTypeInsn(Opcodes.CHECKCAST, getInternalName(pclass));
|
jaroslav@1646
|
436 |
} else {
|
jaroslav@1646
|
437 |
mv.visitLdcInsn(constantPlaceholder(pclass));
|
jaroslav@1646
|
438 |
mv.visitTypeInsn(Opcodes.CHECKCAST, CLS);
|
jaroslav@1646
|
439 |
mv.visitInsn(Opcodes.SWAP);
|
jaroslav@1646
|
440 |
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CLS, "cast", LL_SIG);
|
jaroslav@1646
|
441 |
if (pclass.isArray())
|
jaroslav@1646
|
442 |
mv.visitTypeInsn(Opcodes.CHECKCAST, OBJARY);
|
jaroslav@1646
|
443 |
}
|
jaroslav@1646
|
444 |
return;
|
jaroslav@1646
|
445 |
case 'I':
|
jaroslav@1646
|
446 |
if (!VerifyType.isNullConversion(int.class, pclass))
|
jaroslav@1646
|
447 |
emitPrimCast(ptype, Wrapper.basicTypeChar(pclass));
|
jaroslav@1646
|
448 |
return;
|
jaroslav@1646
|
449 |
case 'J':
|
jaroslav@1646
|
450 |
assert(pclass == long.class);
|
jaroslav@1646
|
451 |
return;
|
jaroslav@1646
|
452 |
case 'F':
|
jaroslav@1646
|
453 |
assert(pclass == float.class);
|
jaroslav@1646
|
454 |
return;
|
jaroslav@1646
|
455 |
case 'D':
|
jaroslav@1646
|
456 |
assert(pclass == double.class);
|
jaroslav@1646
|
457 |
return;
|
jaroslav@1646
|
458 |
}
|
jaroslav@1646
|
459 |
throw new InternalError("bad implicit conversion: tc="+ptype+": "+pclass);
|
jaroslav@1646
|
460 |
}
|
jaroslav@1646
|
461 |
|
jaroslav@1646
|
462 |
/**
|
jaroslav@1646
|
463 |
* Emits an actual return instruction conforming to the given return type.
|
jaroslav@1646
|
464 |
*/
|
jaroslav@1646
|
465 |
private void emitReturnInsn(Class<?> type) {
|
jaroslav@1646
|
466 |
int opcode;
|
jaroslav@1646
|
467 |
switch (Wrapper.basicTypeChar(type)) {
|
jaroslav@1646
|
468 |
case 'I': opcode = Opcodes.IRETURN; break;
|
jaroslav@1646
|
469 |
case 'J': opcode = Opcodes.LRETURN; break;
|
jaroslav@1646
|
470 |
case 'F': opcode = Opcodes.FRETURN; break;
|
jaroslav@1646
|
471 |
case 'D': opcode = Opcodes.DRETURN; break;
|
jaroslav@1646
|
472 |
case 'L': opcode = Opcodes.ARETURN; break;
|
jaroslav@1646
|
473 |
case 'V': opcode = Opcodes.RETURN; break;
|
jaroslav@1646
|
474 |
default:
|
jaroslav@1646
|
475 |
throw new InternalError("unknown return type: " + type);
|
jaroslav@1646
|
476 |
}
|
jaroslav@1646
|
477 |
mv.visitInsn(opcode);
|
jaroslav@1646
|
478 |
}
|
jaroslav@1646
|
479 |
|
jaroslav@1646
|
480 |
private static String getInternalName(Class<?> c) {
|
jaroslav@1646
|
481 |
assert(VerifyAccess.isTypeVisible(c, Object.class));
|
jaroslav@1646
|
482 |
return c.getName().replace('.', '/');
|
jaroslav@1646
|
483 |
}
|
jaroslav@1646
|
484 |
|
jaroslav@1646
|
485 |
/**
|
jaroslav@1646
|
486 |
* Generate customized bytecode for a given LambdaForm.
|
jaroslav@1646
|
487 |
*/
|
jaroslav@1646
|
488 |
static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) {
|
jaroslav@1646
|
489 |
InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("MH", form, invokerType);
|
jaroslav@1646
|
490 |
return g.loadMethod(g.generateCustomizedCodeBytes());
|
jaroslav@1646
|
491 |
}
|
jaroslav@1646
|
492 |
|
jaroslav@1646
|
493 |
/**
|
jaroslav@1646
|
494 |
* Generate an invoker method for the passed {@link LambdaForm}.
|
jaroslav@1646
|
495 |
*/
|
jaroslav@1646
|
496 |
private byte[] generateCustomizedCodeBytes() {
|
jaroslav@1646
|
497 |
classFilePrologue();
|
jaroslav@1646
|
498 |
|
jaroslav@1646
|
499 |
// Suppress this method in backtraces displayed to the user.
|
jaroslav@1646
|
500 |
mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
|
jaroslav@1646
|
501 |
|
jaroslav@1646
|
502 |
// Mark this method as a compiled LambdaForm
|
jaroslav@1646
|
503 |
mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Compiled;", true);
|
jaroslav@1646
|
504 |
|
jaroslav@1646
|
505 |
// Force inlining of this invoker method.
|
jaroslav@1646
|
506 |
mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
|
jaroslav@1646
|
507 |
|
jaroslav@1646
|
508 |
// iterate over the form's names, generating bytecode instructions for each
|
jaroslav@1646
|
509 |
// start iterating at the first name following the arguments
|
jaroslav@1646
|
510 |
for (int i = lambdaForm.arity; i < lambdaForm.names.length; i++) {
|
jaroslav@1646
|
511 |
Name name = lambdaForm.names[i];
|
jaroslav@1646
|
512 |
MemberName member = name.function.member();
|
jaroslav@1646
|
513 |
|
jaroslav@1646
|
514 |
if (isSelectAlternative(member)) {
|
jaroslav@1646
|
515 |
// selectAlternative idiom
|
jaroslav@1646
|
516 |
// FIXME: make sure this idiom is really present!
|
jaroslav@1646
|
517 |
emitSelectAlternative(name, lambdaForm.names[i + 1]);
|
jaroslav@1646
|
518 |
i++; // skip MH.invokeBasic of the selectAlternative result
|
jaroslav@1646
|
519 |
} else if (isStaticallyInvocable(member)) {
|
jaroslav@1646
|
520 |
emitStaticInvoke(member, name);
|
jaroslav@1646
|
521 |
} else {
|
jaroslav@1646
|
522 |
emitInvoke(name);
|
jaroslav@1646
|
523 |
}
|
jaroslav@1646
|
524 |
|
jaroslav@1646
|
525 |
// store the result from evaluating to the target name in a local if required
|
jaroslav@1646
|
526 |
// (if this is the last value, i.e., the one that is going to be returned,
|
jaroslav@1646
|
527 |
// avoid store/load/return and just return)
|
jaroslav@1646
|
528 |
if (i == lambdaForm.names.length - 1 && i == lambdaForm.result) {
|
jaroslav@1646
|
529 |
// return value - do nothing
|
jaroslav@1646
|
530 |
} else if (name.type != 'V') {
|
jaroslav@1646
|
531 |
// non-void: actually assign
|
jaroslav@1646
|
532 |
emitStoreInsn(name.type, name.index());
|
jaroslav@1646
|
533 |
}
|
jaroslav@1646
|
534 |
}
|
jaroslav@1646
|
535 |
|
jaroslav@1646
|
536 |
// return statement
|
jaroslav@1646
|
537 |
emitReturn();
|
jaroslav@1646
|
538 |
|
jaroslav@1646
|
539 |
classFileEpilogue();
|
jaroslav@1646
|
540 |
bogusMethod(lambdaForm);
|
jaroslav@1646
|
541 |
|
jaroslav@1646
|
542 |
final byte[] classFile = cw.toByteArray();
|
jaroslav@1646
|
543 |
maybeDump(className, classFile);
|
jaroslav@1646
|
544 |
return classFile;
|
jaroslav@1646
|
545 |
}
|
jaroslav@1646
|
546 |
|
jaroslav@1646
|
547 |
/**
|
jaroslav@1646
|
548 |
* Emit an invoke for the given name.
|
jaroslav@1646
|
549 |
*/
|
jaroslav@1646
|
550 |
void emitInvoke(Name name) {
|
jaroslav@1646
|
551 |
if (true) {
|
jaroslav@1646
|
552 |
// push receiver
|
jaroslav@1646
|
553 |
MethodHandle target = name.function.resolvedHandle;
|
jaroslav@1646
|
554 |
assert(target != null) : name.exprString();
|
jaroslav@1646
|
555 |
mv.visitLdcInsn(constantPlaceholder(target));
|
jaroslav@1646
|
556 |
mv.visitTypeInsn(Opcodes.CHECKCAST, MH);
|
jaroslav@1646
|
557 |
} else {
|
jaroslav@1646
|
558 |
// load receiver
|
jaroslav@1646
|
559 |
emitAloadInsn(0);
|
jaroslav@1646
|
560 |
mv.visitTypeInsn(Opcodes.CHECKCAST, MH);
|
jaroslav@1646
|
561 |
mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", LF_SIG);
|
jaroslav@1646
|
562 |
mv.visitFieldInsn(Opcodes.GETFIELD, LF, "names", LFN_SIG);
|
jaroslav@1646
|
563 |
// TODO more to come
|
jaroslav@1646
|
564 |
}
|
jaroslav@1646
|
565 |
|
jaroslav@1646
|
566 |
// push arguments
|
jaroslav@1646
|
567 |
for (int i = 0; i < name.arguments.length; i++) {
|
jaroslav@1646
|
568 |
emitPushArgument(name, i);
|
jaroslav@1646
|
569 |
}
|
jaroslav@1646
|
570 |
|
jaroslav@1646
|
571 |
// invocation
|
jaroslav@1646
|
572 |
MethodType type = name.function.methodType();
|
jaroslav@1646
|
573 |
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", type.basicType().toMethodDescriptorString());
|
jaroslav@1646
|
574 |
}
|
jaroslav@1646
|
575 |
|
jaroslav@1646
|
576 |
static private Class<?>[] STATICALLY_INVOCABLE_PACKAGES = {
|
jaroslav@1646
|
577 |
// Sample classes from each package we are willing to bind to statically:
|
jaroslav@1646
|
578 |
java.lang.Object.class,
|
jaroslav@1646
|
579 |
java.util.Arrays.class,
|
jaroslav@1646
|
580 |
sun.misc.Unsafe.class
|
jaroslav@1646
|
581 |
//MethodHandle.class already covered
|
jaroslav@1646
|
582 |
};
|
jaroslav@1646
|
583 |
|
jaroslav@1646
|
584 |
static boolean isStaticallyInvocable(MemberName member) {
|
jaroslav@1646
|
585 |
if (member == null) return false;
|
jaroslav@1646
|
586 |
if (member.isConstructor()) return false;
|
jaroslav@1646
|
587 |
Class<?> cls = member.getDeclaringClass();
|
jaroslav@1646
|
588 |
if (cls.isArray() || cls.isPrimitive())
|
jaroslav@1646
|
589 |
return false; // FIXME
|
jaroslav@1646
|
590 |
if (cls.isAnonymousClass() || cls.isLocalClass())
|
jaroslav@1646
|
591 |
return false; // inner class of some sort
|
jaroslav@1646
|
592 |
if (cls.getClassLoader() != MethodHandle.class.getClassLoader())
|
jaroslav@1646
|
593 |
return false; // not on BCP
|
jaroslav@1646
|
594 |
MethodType mtype = member.getMethodOrFieldType();
|
jaroslav@1646
|
595 |
if (!isStaticallyNameable(mtype.returnType()))
|
jaroslav@1646
|
596 |
return false;
|
jaroslav@1646
|
597 |
for (Class<?> ptype : mtype.parameterArray())
|
jaroslav@1646
|
598 |
if (!isStaticallyNameable(ptype))
|
jaroslav@1646
|
599 |
return false;
|
jaroslav@1646
|
600 |
if (!member.isPrivate() && VerifyAccess.isSamePackage(MethodHandle.class, cls))
|
jaroslav@1646
|
601 |
return true; // in java.lang.invoke package
|
jaroslav@1646
|
602 |
if (member.isPublic() && isStaticallyNameable(cls))
|
jaroslav@1646
|
603 |
return true;
|
jaroslav@1646
|
604 |
return false;
|
jaroslav@1646
|
605 |
}
|
jaroslav@1646
|
606 |
|
jaroslav@1646
|
607 |
static boolean isStaticallyNameable(Class<?> cls) {
|
jaroslav@1646
|
608 |
while (cls.isArray())
|
jaroslav@1646
|
609 |
cls = cls.getComponentType();
|
jaroslav@1646
|
610 |
if (cls.isPrimitive())
|
jaroslav@1646
|
611 |
return true; // int[].class, for example
|
jaroslav@1646
|
612 |
// could use VerifyAccess.isClassAccessible but the following is a safe approximation
|
jaroslav@1646
|
613 |
if (cls.getClassLoader() != Object.class.getClassLoader())
|
jaroslav@1646
|
614 |
return false;
|
jaroslav@1646
|
615 |
if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
|
jaroslav@1646
|
616 |
return true;
|
jaroslav@1646
|
617 |
if (!Modifier.isPublic(cls.getModifiers()))
|
jaroslav@1646
|
618 |
return false;
|
jaroslav@1646
|
619 |
for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
|
jaroslav@1646
|
620 |
if (VerifyAccess.isSamePackage(pkgcls, cls))
|
jaroslav@1646
|
621 |
return true;
|
jaroslav@1646
|
622 |
}
|
jaroslav@1646
|
623 |
return false;
|
jaroslav@1646
|
624 |
}
|
jaroslav@1646
|
625 |
|
jaroslav@1646
|
626 |
/**
|
jaroslav@1646
|
627 |
* Emit an invoke for the given name, using the MemberName directly.
|
jaroslav@1646
|
628 |
*/
|
jaroslav@1646
|
629 |
void emitStaticInvoke(MemberName member, Name name) {
|
jaroslav@1646
|
630 |
assert(member.equals(name.function.member()));
|
jaroslav@1646
|
631 |
String cname = getInternalName(member.getDeclaringClass());
|
jaroslav@1646
|
632 |
String mname = member.getName();
|
jaroslav@1646
|
633 |
String mtype;
|
jaroslav@1646
|
634 |
byte refKind = member.getReferenceKind();
|
jaroslav@1646
|
635 |
if (refKind == REF_invokeSpecial) {
|
jaroslav@1646
|
636 |
// in order to pass the verifier, we need to convert this to invokevirtual in all cases
|
jaroslav@1646
|
637 |
assert(member.canBeStaticallyBound()) : member;
|
jaroslav@1646
|
638 |
refKind = REF_invokeVirtual;
|
jaroslav@1646
|
639 |
}
|
jaroslav@1646
|
640 |
|
jaroslav@1646
|
641 |
if (member.getDeclaringClass().isInterface() && refKind == REF_invokeVirtual) {
|
jaroslav@1646
|
642 |
// Methods from Object declared in an interface can be resolved by JVM to invokevirtual kind.
|
jaroslav@1646
|
643 |
// Need to convert it back to invokeinterface to pass verification and make the invocation works as expected.
|
jaroslav@1646
|
644 |
refKind = REF_invokeInterface;
|
jaroslav@1646
|
645 |
}
|
jaroslav@1646
|
646 |
|
jaroslav@1646
|
647 |
// push arguments
|
jaroslav@1646
|
648 |
for (int i = 0; i < name.arguments.length; i++) {
|
jaroslav@1646
|
649 |
emitPushArgument(name, i);
|
jaroslav@1646
|
650 |
}
|
jaroslav@1646
|
651 |
|
jaroslav@1646
|
652 |
// invocation
|
jaroslav@1646
|
653 |
if (member.isMethod()) {
|
jaroslav@1646
|
654 |
mtype = member.getMethodType().toMethodDescriptorString();
|
jaroslav@1646
|
655 |
mv.visitMethodInsn(refKindOpcode(refKind), cname, mname, mtype,
|
jaroslav@1646
|
656 |
member.getDeclaringClass().isInterface());
|
jaroslav@1646
|
657 |
} else {
|
jaroslav@1646
|
658 |
mtype = MethodType.toFieldDescriptorString(member.getFieldType());
|
jaroslav@1646
|
659 |
mv.visitFieldInsn(refKindOpcode(refKind), cname, mname, mtype);
|
jaroslav@1646
|
660 |
}
|
jaroslav@1646
|
661 |
}
|
jaroslav@1646
|
662 |
int refKindOpcode(byte refKind) {
|
jaroslav@1646
|
663 |
switch (refKind) {
|
jaroslav@1646
|
664 |
case REF_invokeVirtual: return Opcodes.INVOKEVIRTUAL;
|
jaroslav@1646
|
665 |
case REF_invokeStatic: return Opcodes.INVOKESTATIC;
|
jaroslav@1646
|
666 |
case REF_invokeSpecial: return Opcodes.INVOKESPECIAL;
|
jaroslav@1646
|
667 |
case REF_invokeInterface: return Opcodes.INVOKEINTERFACE;
|
jaroslav@1646
|
668 |
case REF_getField: return Opcodes.GETFIELD;
|
jaroslav@1646
|
669 |
case REF_putField: return Opcodes.PUTFIELD;
|
jaroslav@1646
|
670 |
case REF_getStatic: return Opcodes.GETSTATIC;
|
jaroslav@1646
|
671 |
case REF_putStatic: return Opcodes.PUTSTATIC;
|
jaroslav@1646
|
672 |
}
|
jaroslav@1646
|
673 |
throw new InternalError("refKind="+refKind);
|
jaroslav@1646
|
674 |
}
|
jaroslav@1646
|
675 |
|
jaroslav@1646
|
676 |
/**
|
jaroslav@1646
|
677 |
* Check if MemberName is a call to MethodHandleImpl.selectAlternative.
|
jaroslav@1646
|
678 |
*/
|
jaroslav@1646
|
679 |
private boolean isSelectAlternative(MemberName member) {
|
jaroslav@1646
|
680 |
return member != null &&
|
jaroslav@1646
|
681 |
member.getDeclaringClass() == MethodHandleImpl.class &&
|
jaroslav@1646
|
682 |
member.getName().equals("selectAlternative");
|
jaroslav@1646
|
683 |
}
|
jaroslav@1646
|
684 |
|
jaroslav@1646
|
685 |
/**
|
jaroslav@1646
|
686 |
* Emit bytecode for the selectAlternative idiom.
|
jaroslav@1646
|
687 |
*
|
jaroslav@1646
|
688 |
* The pattern looks like (Cf. MethodHandleImpl.makeGuardWithTest):
|
jaroslav@1646
|
689 |
* <blockquote><pre>{@code
|
jaroslav@1646
|
690 |
* Lambda(a0:L,a1:I)=>{
|
jaroslav@1646
|
691 |
* t2:I=foo.test(a1:I);
|
jaroslav@1646
|
692 |
* t3:L=MethodHandleImpl.selectAlternative(t2:I,(MethodHandle(int)int),(MethodHandle(int)int));
|
jaroslav@1646
|
693 |
* t4:I=MethodHandle.invokeBasic(t3:L,a1:I);t4:I}
|
jaroslav@1646
|
694 |
* }</pre></blockquote>
|
jaroslav@1646
|
695 |
*/
|
jaroslav@1646
|
696 |
private void emitSelectAlternative(Name selectAlternativeName, Name invokeBasicName) {
|
jaroslav@1646
|
697 |
MethodType type = selectAlternativeName.function.methodType();
|
jaroslav@1646
|
698 |
|
jaroslav@1646
|
699 |
Name receiver = (Name) invokeBasicName.arguments[0];
|
jaroslav@1646
|
700 |
|
jaroslav@1646
|
701 |
Label L_fallback = new Label();
|
jaroslav@1646
|
702 |
Label L_done = new Label();
|
jaroslav@1646
|
703 |
|
jaroslav@1646
|
704 |
// load test result
|
jaroslav@1646
|
705 |
emitPushArgument(selectAlternativeName, 0);
|
jaroslav@1646
|
706 |
mv.visitInsn(Opcodes.ICONST_1);
|
jaroslav@1646
|
707 |
|
jaroslav@1646
|
708 |
// if_icmpne L_fallback
|
jaroslav@1646
|
709 |
mv.visitJumpInsn(Opcodes.IF_ICMPNE, L_fallback);
|
jaroslav@1646
|
710 |
|
jaroslav@1646
|
711 |
// invoke selectAlternativeName.arguments[1]
|
jaroslav@1646
|
712 |
MethodHandle target = (MethodHandle) selectAlternativeName.arguments[1];
|
jaroslav@1646
|
713 |
emitPushArgument(selectAlternativeName, 1); // get 2nd argument of selectAlternative
|
jaroslav@1646
|
714 |
emitAstoreInsn(receiver.index()); // store the MH in the receiver slot
|
jaroslav@1646
|
715 |
emitInvoke(invokeBasicName);
|
jaroslav@1646
|
716 |
|
jaroslav@1646
|
717 |
// goto L_done
|
jaroslav@1646
|
718 |
mv.visitJumpInsn(Opcodes.GOTO, L_done);
|
jaroslav@1646
|
719 |
|
jaroslav@1646
|
720 |
// L_fallback:
|
jaroslav@1646
|
721 |
mv.visitLabel(L_fallback);
|
jaroslav@1646
|
722 |
|
jaroslav@1646
|
723 |
// invoke selectAlternativeName.arguments[2]
|
jaroslav@1646
|
724 |
MethodHandle fallback = (MethodHandle) selectAlternativeName.arguments[2];
|
jaroslav@1646
|
725 |
emitPushArgument(selectAlternativeName, 2); // get 3rd argument of selectAlternative
|
jaroslav@1646
|
726 |
emitAstoreInsn(receiver.index()); // store the MH in the receiver slot
|
jaroslav@1646
|
727 |
emitInvoke(invokeBasicName);
|
jaroslav@1646
|
728 |
|
jaroslav@1646
|
729 |
// L_done:
|
jaroslav@1646
|
730 |
mv.visitLabel(L_done);
|
jaroslav@1646
|
731 |
}
|
jaroslav@1646
|
732 |
|
jaroslav@1646
|
733 |
private void emitPushArgument(Name name, int paramIndex) {
|
jaroslav@1646
|
734 |
Object arg = name.arguments[paramIndex];
|
jaroslav@1646
|
735 |
char ptype = name.function.parameterType(paramIndex);
|
jaroslav@1646
|
736 |
MethodType mtype = name.function.methodType();
|
jaroslav@1646
|
737 |
if (arg instanceof Name) {
|
jaroslav@1646
|
738 |
Name n = (Name) arg;
|
jaroslav@1646
|
739 |
emitLoadInsn(n.type, n.index());
|
jaroslav@1646
|
740 |
emitImplicitConversion(n.type, mtype.parameterType(paramIndex));
|
jaroslav@1646
|
741 |
} else if ((arg == null || arg instanceof String) && ptype == 'L') {
|
jaroslav@1646
|
742 |
emitConst(arg);
|
jaroslav@1646
|
743 |
} else {
|
jaroslav@1646
|
744 |
if (Wrapper.isWrapperType(arg.getClass()) && ptype != 'L') {
|
jaroslav@1646
|
745 |
emitConst(arg);
|
jaroslav@1646
|
746 |
} else {
|
jaroslav@1646
|
747 |
mv.visitLdcInsn(constantPlaceholder(arg));
|
jaroslav@1646
|
748 |
emitImplicitConversion('L', mtype.parameterType(paramIndex));
|
jaroslav@1646
|
749 |
}
|
jaroslav@1646
|
750 |
}
|
jaroslav@1646
|
751 |
}
|
jaroslav@1646
|
752 |
|
jaroslav@1646
|
753 |
/**
|
jaroslav@1646
|
754 |
* Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.
|
jaroslav@1646
|
755 |
*/
|
jaroslav@1646
|
756 |
private void emitReturn() {
|
jaroslav@1646
|
757 |
// return statement
|
jaroslav@1646
|
758 |
if (lambdaForm.result == -1) {
|
jaroslav@1646
|
759 |
// void
|
jaroslav@1646
|
760 |
mv.visitInsn(Opcodes.RETURN);
|
jaroslav@1646
|
761 |
} else {
|
jaroslav@1646
|
762 |
LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
|
jaroslav@1646
|
763 |
char rtype = Wrapper.basicTypeChar(invokerType.returnType());
|
jaroslav@1646
|
764 |
|
jaroslav@1646
|
765 |
// put return value on the stack if it is not already there
|
jaroslav@1646
|
766 |
if (lambdaForm.result != lambdaForm.names.length - 1) {
|
jaroslav@1646
|
767 |
emitLoadInsn(rn.type, lambdaForm.result);
|
jaroslav@1646
|
768 |
}
|
jaroslav@1646
|
769 |
|
jaroslav@1646
|
770 |
// potentially generate cast
|
jaroslav@1646
|
771 |
// rtype is the return type of the invoker - generated code must conform to this
|
jaroslav@1646
|
772 |
// rn.type is the type of the result Name in the LF
|
jaroslav@1646
|
773 |
if (rtype != rn.type) {
|
jaroslav@1646
|
774 |
// need cast
|
jaroslav@1646
|
775 |
if (rtype == 'L') {
|
jaroslav@1646
|
776 |
// possibly cast the primitive to the correct type for boxing
|
jaroslav@1646
|
777 |
char boxedType = Wrapper.forWrapperType(invokerType.returnType()).basicTypeChar();
|
jaroslav@1646
|
778 |
if (boxedType != rn.type) {
|
jaroslav@1646
|
779 |
emitPrimCast(rn.type, boxedType);
|
jaroslav@1646
|
780 |
}
|
jaroslav@1646
|
781 |
// cast primitive to reference ("boxing")
|
jaroslav@1646
|
782 |
emitBoxing(invokerType.returnType());
|
jaroslav@1646
|
783 |
} else {
|
jaroslav@1646
|
784 |
// to-primitive cast
|
jaroslav@1646
|
785 |
if (rn.type != 'L') {
|
jaroslav@1646
|
786 |
// prim-to-prim cast
|
jaroslav@1646
|
787 |
emitPrimCast(rn.type, rtype);
|
jaroslav@1646
|
788 |
} else {
|
jaroslav@1646
|
789 |
// ref-to-prim cast ("unboxing")
|
jaroslav@1646
|
790 |
throw new InternalError("no ref-to-prim (unboxing) casts supported right now");
|
jaroslav@1646
|
791 |
}
|
jaroslav@1646
|
792 |
}
|
jaroslav@1646
|
793 |
}
|
jaroslav@1646
|
794 |
|
jaroslav@1646
|
795 |
// generate actual return statement
|
jaroslav@1646
|
796 |
emitReturnInsn(invokerType.returnType());
|
jaroslav@1646
|
797 |
}
|
jaroslav@1646
|
798 |
}
|
jaroslav@1646
|
799 |
|
jaroslav@1646
|
800 |
/**
|
jaroslav@1646
|
801 |
* Emit a type conversion bytecode casting from "from" to "to".
|
jaroslav@1646
|
802 |
*/
|
jaroslav@1646
|
803 |
private void emitPrimCast(char from, char to) {
|
jaroslav@1646
|
804 |
// Here's how.
|
jaroslav@1646
|
805 |
// - indicates forbidden
|
jaroslav@1646
|
806 |
// <-> indicates implicit
|
jaroslav@1646
|
807 |
// to ----> boolean byte short char int long float double
|
jaroslav@1646
|
808 |
// from boolean <-> - - - - - - -
|
jaroslav@1646
|
809 |
// byte - <-> i2s i2c <-> i2l i2f i2d
|
jaroslav@1646
|
810 |
// short - i2b <-> i2c <-> i2l i2f i2d
|
jaroslav@1646
|
811 |
// char - i2b i2s <-> <-> i2l i2f i2d
|
jaroslav@1646
|
812 |
// int - i2b i2s i2c <-> i2l i2f i2d
|
jaroslav@1646
|
813 |
// long - l2i,i2b l2i,i2s l2i,i2c l2i <-> l2f l2d
|
jaroslav@1646
|
814 |
// float - f2i,i2b f2i,i2s f2i,i2c f2i f2l <-> f2d
|
jaroslav@1646
|
815 |
// double - d2i,i2b d2i,i2s d2i,i2c d2i d2l d2f <->
|
jaroslav@1646
|
816 |
if (from == to) {
|
jaroslav@1646
|
817 |
// no cast required, should be dead code anyway
|
jaroslav@1646
|
818 |
return;
|
jaroslav@1646
|
819 |
}
|
jaroslav@1646
|
820 |
Wrapper wfrom = Wrapper.forBasicType(from);
|
jaroslav@1646
|
821 |
Wrapper wto = Wrapper.forBasicType(to);
|
jaroslav@1646
|
822 |
if (wfrom.isSubwordOrInt()) {
|
jaroslav@1646
|
823 |
// cast from {byte,short,char,int} to anything
|
jaroslav@1646
|
824 |
emitI2X(to);
|
jaroslav@1646
|
825 |
} else {
|
jaroslav@1646
|
826 |
// cast from {long,float,double} to anything
|
jaroslav@1646
|
827 |
if (wto.isSubwordOrInt()) {
|
jaroslav@1646
|
828 |
// cast to {byte,short,char,int}
|
jaroslav@1646
|
829 |
emitX2I(from);
|
jaroslav@1646
|
830 |
if (wto.bitWidth() < 32) {
|
jaroslav@1646
|
831 |
// targets other than int require another conversion
|
jaroslav@1646
|
832 |
emitI2X(to);
|
jaroslav@1646
|
833 |
}
|
jaroslav@1646
|
834 |
} else {
|
jaroslav@1646
|
835 |
// cast to {long,float,double} - this is verbose
|
jaroslav@1646
|
836 |
boolean error = false;
|
jaroslav@1646
|
837 |
switch (from) {
|
jaroslav@1646
|
838 |
case 'J':
|
jaroslav@1646
|
839 |
if (to == 'F') { mv.visitInsn(Opcodes.L2F); }
|
jaroslav@1646
|
840 |
else if (to == 'D') { mv.visitInsn(Opcodes.L2D); }
|
jaroslav@1646
|
841 |
else error = true;
|
jaroslav@1646
|
842 |
break;
|
jaroslav@1646
|
843 |
case 'F':
|
jaroslav@1646
|
844 |
if (to == 'J') { mv.visitInsn(Opcodes.F2L); }
|
jaroslav@1646
|
845 |
else if (to == 'D') { mv.visitInsn(Opcodes.F2D); }
|
jaroslav@1646
|
846 |
else error = true;
|
jaroslav@1646
|
847 |
break;
|
jaroslav@1646
|
848 |
case 'D':
|
jaroslav@1646
|
849 |
if (to == 'J') { mv.visitInsn(Opcodes.D2L); }
|
jaroslav@1646
|
850 |
else if (to == 'F') { mv.visitInsn(Opcodes.D2F); }
|
jaroslav@1646
|
851 |
else error = true;
|
jaroslav@1646
|
852 |
break;
|
jaroslav@1646
|
853 |
default:
|
jaroslav@1646
|
854 |
error = true;
|
jaroslav@1646
|
855 |
break;
|
jaroslav@1646
|
856 |
}
|
jaroslav@1646
|
857 |
if (error) {
|
jaroslav@1646
|
858 |
throw new IllegalStateException("unhandled prim cast: " + from + "2" + to);
|
jaroslav@1646
|
859 |
}
|
jaroslav@1646
|
860 |
}
|
jaroslav@1646
|
861 |
}
|
jaroslav@1646
|
862 |
}
|
jaroslav@1646
|
863 |
|
jaroslav@1646
|
864 |
private void emitI2X(char type) {
|
jaroslav@1646
|
865 |
switch (type) {
|
jaroslav@1646
|
866 |
case 'B': mv.visitInsn(Opcodes.I2B); break;
|
jaroslav@1646
|
867 |
case 'S': mv.visitInsn(Opcodes.I2S); break;
|
jaroslav@1646
|
868 |
case 'C': mv.visitInsn(Opcodes.I2C); break;
|
jaroslav@1646
|
869 |
case 'I': /* naught */ break;
|
jaroslav@1646
|
870 |
case 'J': mv.visitInsn(Opcodes.I2L); break;
|
jaroslav@1646
|
871 |
case 'F': mv.visitInsn(Opcodes.I2F); break;
|
jaroslav@1646
|
872 |
case 'D': mv.visitInsn(Opcodes.I2D); break;
|
jaroslav@1646
|
873 |
case 'Z':
|
jaroslav@1646
|
874 |
// For compatibility with ValueConversions and explicitCastArguments:
|
jaroslav@1646
|
875 |
mv.visitInsn(Opcodes.ICONST_1);
|
jaroslav@1646
|
876 |
mv.visitInsn(Opcodes.IAND);
|
jaroslav@1646
|
877 |
break;
|
jaroslav@1646
|
878 |
default: throw new InternalError("unknown type: " + type);
|
jaroslav@1646
|
879 |
}
|
jaroslav@1646
|
880 |
}
|
jaroslav@1646
|
881 |
|
jaroslav@1646
|
882 |
private void emitX2I(char type) {
|
jaroslav@1646
|
883 |
switch (type) {
|
jaroslav@1646
|
884 |
case 'J': mv.visitInsn(Opcodes.L2I); break;
|
jaroslav@1646
|
885 |
case 'F': mv.visitInsn(Opcodes.F2I); break;
|
jaroslav@1646
|
886 |
case 'D': mv.visitInsn(Opcodes.D2I); break;
|
jaroslav@1646
|
887 |
default: throw new InternalError("unknown type: " + type);
|
jaroslav@1646
|
888 |
}
|
jaroslav@1646
|
889 |
}
|
jaroslav@1646
|
890 |
|
jaroslav@1646
|
891 |
private static String basicTypeCharSignature(String prefix, MethodType type) {
|
jaroslav@1646
|
892 |
StringBuilder buf = new StringBuilder(prefix);
|
jaroslav@1646
|
893 |
for (Class<?> ptype : type.parameterList())
|
jaroslav@1646
|
894 |
buf.append(Wrapper.forBasicType(ptype).basicTypeChar());
|
jaroslav@1646
|
895 |
buf.append('_').append(Wrapper.forBasicType(type.returnType()).basicTypeChar());
|
jaroslav@1646
|
896 |
return buf.toString();
|
jaroslav@1646
|
897 |
}
|
jaroslav@1646
|
898 |
|
jaroslav@1646
|
899 |
/**
|
jaroslav@1646
|
900 |
* Generate bytecode for a LambdaForm.vmentry which calls interpretWithArguments.
|
jaroslav@1646
|
901 |
*/
|
jaroslav@1646
|
902 |
static MemberName generateLambdaFormInterpreterEntryPoint(String sig) {
|
jaroslav@1646
|
903 |
assert(LambdaForm.isValidSignature(sig));
|
jaroslav@1646
|
904 |
//System.out.println("generateExactInvoker "+sig);
|
jaroslav@1646
|
905 |
// compute method type
|
jaroslav@1646
|
906 |
// first parameter and return type
|
jaroslav@1646
|
907 |
char tret = LambdaForm.signatureReturn(sig);
|
jaroslav@1646
|
908 |
MethodType type = MethodType.methodType(LambdaForm.typeClass(tret), MethodHandle.class);
|
jaroslav@1646
|
909 |
// other parameter types
|
jaroslav@1646
|
910 |
int arity = LambdaForm.signatureArity(sig);
|
jaroslav@1646
|
911 |
for (int i = 1; i < arity; i++) {
|
jaroslav@1646
|
912 |
type = type.appendParameterTypes(LambdaForm.typeClass(sig.charAt(i)));
|
jaroslav@1646
|
913 |
}
|
jaroslav@1646
|
914 |
InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("LFI", "interpret_"+tret, type);
|
jaroslav@1646
|
915 |
return g.loadMethod(g.generateLambdaFormInterpreterEntryPointBytes());
|
jaroslav@1646
|
916 |
}
|
jaroslav@1646
|
917 |
|
jaroslav@1646
|
918 |
private byte[] generateLambdaFormInterpreterEntryPointBytes() {
|
jaroslav@1646
|
919 |
classFilePrologue();
|
jaroslav@1646
|
920 |
|
jaroslav@1646
|
921 |
// Suppress this method in backtraces displayed to the user.
|
jaroslav@1646
|
922 |
mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
|
jaroslav@1646
|
923 |
|
jaroslav@1646
|
924 |
// Don't inline the interpreter entry.
|
jaroslav@1646
|
925 |
mv.visitAnnotation("Ljava/lang/invoke/DontInline;", true);
|
jaroslav@1646
|
926 |
|
jaroslav@1646
|
927 |
// create parameter array
|
jaroslav@1646
|
928 |
emitIconstInsn(invokerType.parameterCount());
|
jaroslav@1646
|
929 |
mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
|
jaroslav@1646
|
930 |
|
jaroslav@1646
|
931 |
// fill parameter array
|
jaroslav@1646
|
932 |
for (int i = 0; i < invokerType.parameterCount(); i++) {
|
jaroslav@1646
|
933 |
Class<?> ptype = invokerType.parameterType(i);
|
jaroslav@1646
|
934 |
mv.visitInsn(Opcodes.DUP);
|
jaroslav@1646
|
935 |
emitIconstInsn(i);
|
jaroslav@1646
|
936 |
emitLoadInsn(Wrapper.basicTypeChar(ptype), i);
|
jaroslav@1646
|
937 |
// box if primitive type
|
jaroslav@1646
|
938 |
if (ptype.isPrimitive()) {
|
jaroslav@1646
|
939 |
emitBoxing(ptype);
|
jaroslav@1646
|
940 |
}
|
jaroslav@1646
|
941 |
mv.visitInsn(Opcodes.AASTORE);
|
jaroslav@1646
|
942 |
}
|
jaroslav@1646
|
943 |
// invoke
|
jaroslav@1646
|
944 |
emitAloadInsn(0);
|
jaroslav@1646
|
945 |
mv.visitFieldInsn(Opcodes.GETFIELD, MH, "form", "Ljava/lang/invoke/LambdaForm;");
|
jaroslav@1646
|
946 |
mv.visitInsn(Opcodes.SWAP); // swap form and array; avoid local variable
|
jaroslav@1646
|
947 |
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, LF, "interpretWithArguments", "([Ljava/lang/Object;)Ljava/lang/Object;");
|
jaroslav@1646
|
948 |
|
jaroslav@1646
|
949 |
// maybe unbox
|
jaroslav@1646
|
950 |
Class<?> rtype = invokerType.returnType();
|
jaroslav@1646
|
951 |
if (rtype.isPrimitive() && rtype != void.class) {
|
jaroslav@1646
|
952 |
emitUnboxing(Wrapper.asWrapperType(rtype));
|
jaroslav@1646
|
953 |
}
|
jaroslav@1646
|
954 |
|
jaroslav@1646
|
955 |
// return statement
|
jaroslav@1646
|
956 |
emitReturnInsn(rtype);
|
jaroslav@1646
|
957 |
|
jaroslav@1646
|
958 |
classFileEpilogue();
|
jaroslav@1646
|
959 |
bogusMethod(invokerType);
|
jaroslav@1646
|
960 |
|
jaroslav@1646
|
961 |
final byte[] classFile = cw.toByteArray();
|
jaroslav@1646
|
962 |
maybeDump(className, classFile);
|
jaroslav@1646
|
963 |
return classFile;
|
jaroslav@1646
|
964 |
}
|
jaroslav@1646
|
965 |
|
jaroslav@1646
|
966 |
/**
|
jaroslav@1646
|
967 |
* Generate bytecode for a NamedFunction invoker.
|
jaroslav@1646
|
968 |
*/
|
jaroslav@1646
|
969 |
static MemberName generateNamedFunctionInvoker(MethodTypeForm typeForm) {
|
jaroslav@1646
|
970 |
MethodType invokerType = LambdaForm.NamedFunction.INVOKER_METHOD_TYPE;
|
jaroslav@1646
|
971 |
String invokerName = basicTypeCharSignature("invoke_", typeForm.erasedType());
|
jaroslav@1646
|
972 |
InvokerBytecodeGenerator g = new InvokerBytecodeGenerator("NFI", invokerName, invokerType);
|
jaroslav@1646
|
973 |
return g.loadMethod(g.generateNamedFunctionInvokerImpl(typeForm));
|
jaroslav@1646
|
974 |
}
|
jaroslav@1646
|
975 |
|
jaroslav@1646
|
976 |
static int nfi = 0;
|
jaroslav@1646
|
977 |
|
jaroslav@1646
|
978 |
private byte[] generateNamedFunctionInvokerImpl(MethodTypeForm typeForm) {
|
jaroslav@1646
|
979 |
MethodType dstType = typeForm.erasedType();
|
jaroslav@1646
|
980 |
classFilePrologue();
|
jaroslav@1646
|
981 |
|
jaroslav@1646
|
982 |
// Suppress this method in backtraces displayed to the user.
|
jaroslav@1646
|
983 |
mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true);
|
jaroslav@1646
|
984 |
|
jaroslav@1646
|
985 |
// Force inlining of this invoker method.
|
jaroslav@1646
|
986 |
mv.visitAnnotation("Ljava/lang/invoke/ForceInline;", true);
|
jaroslav@1646
|
987 |
|
jaroslav@1646
|
988 |
// Load receiver
|
jaroslav@1646
|
989 |
emitAloadInsn(0);
|
jaroslav@1646
|
990 |
|
jaroslav@1646
|
991 |
// Load arguments from array
|
jaroslav@1646
|
992 |
for (int i = 0; i < dstType.parameterCount(); i++) {
|
jaroslav@1646
|
993 |
emitAloadInsn(1);
|
jaroslav@1646
|
994 |
emitIconstInsn(i);
|
jaroslav@1646
|
995 |
mv.visitInsn(Opcodes.AALOAD);
|
jaroslav@1646
|
996 |
|
jaroslav@1646
|
997 |
// Maybe unbox
|
jaroslav@1646
|
998 |
Class<?> dptype = dstType.parameterType(i);
|
jaroslav@1646
|
999 |
if (dptype.isPrimitive()) {
|
jaroslav@1646
|
1000 |
Class<?> sptype = dstType.basicType().wrap().parameterType(i);
|
jaroslav@1646
|
1001 |
Wrapper dstWrapper = Wrapper.forBasicType(dptype);
|
jaroslav@1646
|
1002 |
Wrapper srcWrapper = dstWrapper.isSubwordOrInt() ? Wrapper.INT : dstWrapper; // narrow subword from int
|
jaroslav@1646
|
1003 |
emitUnboxing(srcWrapper.wrapperType());
|
jaroslav@1646
|
1004 |
emitPrimCast(srcWrapper.basicTypeChar(), dstWrapper.basicTypeChar());
|
jaroslav@1646
|
1005 |
}
|
jaroslav@1646
|
1006 |
}
|
jaroslav@1646
|
1007 |
|
jaroslav@1646
|
1008 |
// Invoke
|
jaroslav@1646
|
1009 |
String targetDesc = dstType.basicType().toMethodDescriptorString();
|
jaroslav@1646
|
1010 |
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, MH, "invokeBasic", targetDesc);
|
jaroslav@1646
|
1011 |
|
jaroslav@1646
|
1012 |
// Box primitive types
|
jaroslav@1646
|
1013 |
Class<?> rtype = dstType.returnType();
|
jaroslav@1646
|
1014 |
if (rtype != void.class && rtype.isPrimitive()) {
|
jaroslav@1646
|
1015 |
Wrapper srcWrapper = Wrapper.forBasicType(rtype);
|
jaroslav@1646
|
1016 |
Wrapper dstWrapper = srcWrapper.isSubwordOrInt() ? Wrapper.INT : srcWrapper; // widen subword to int
|
jaroslav@1646
|
1017 |
// boolean casts not allowed
|
jaroslav@1646
|
1018 |
emitPrimCast(srcWrapper.basicTypeChar(), dstWrapper.basicTypeChar());
|
jaroslav@1646
|
1019 |
emitBoxing(dstWrapper.primitiveType());
|
jaroslav@1646
|
1020 |
}
|
jaroslav@1646
|
1021 |
|
jaroslav@1646
|
1022 |
// If the return type is void we return a null reference.
|
jaroslav@1646
|
1023 |
if (rtype == void.class) {
|
jaroslav@1646
|
1024 |
mv.visitInsn(Opcodes.ACONST_NULL);
|
jaroslav@1646
|
1025 |
}
|
jaroslav@1646
|
1026 |
emitReturnInsn(Object.class); // NOTE: NamedFunction invokers always return a reference value.
|
jaroslav@1646
|
1027 |
|
jaroslav@1646
|
1028 |
classFileEpilogue();
|
jaroslav@1646
|
1029 |
bogusMethod(dstType);
|
jaroslav@1646
|
1030 |
|
jaroslav@1646
|
1031 |
final byte[] classFile = cw.toByteArray();
|
jaroslav@1646
|
1032 |
maybeDump(className, classFile);
|
jaroslav@1646
|
1033 |
return classFile;
|
jaroslav@1646
|
1034 |
}
|
jaroslav@1646
|
1035 |
|
jaroslav@1646
|
1036 |
/**
|
jaroslav@1646
|
1037 |
* Emit a bogus method that just loads some string constants. This is to get the constants into the constant pool
|
jaroslav@1646
|
1038 |
* for debugging purposes.
|
jaroslav@1646
|
1039 |
*/
|
jaroslav@1646
|
1040 |
private void bogusMethod(Object... os) {
|
jaroslav@1646
|
1041 |
if (DUMP_CLASS_FILES) {
|
jaroslav@1646
|
1042 |
mv = cw.visitMethod(Opcodes.ACC_STATIC, "dummy", "()V", null, null);
|
jaroslav@1646
|
1043 |
for (Object o : os) {
|
jaroslav@1646
|
1044 |
mv.visitLdcInsn(o.toString());
|
jaroslav@1646
|
1045 |
mv.visitInsn(Opcodes.POP);
|
jaroslav@1646
|
1046 |
}
|
jaroslav@1646
|
1047 |
mv.visitInsn(Opcodes.RETURN);
|
jaroslav@1646
|
1048 |
mv.visitMaxs(0, 0);
|
jaroslav@1646
|
1049 |
mv.visitEnd();
|
jaroslav@1646
|
1050 |
}
|
jaroslav@1646
|
1051 |
}
|
jaroslav@1646
|
1052 |
}
|