1 /* |
|
2 * Copyright (c) 2001, 2013, 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 |
|
26 package sun.reflect; |
|
27 |
|
28 import java.lang.reflect.*; |
|
29 import jdk.internal.misc.Unsafe; |
|
30 |
|
31 /** Shared functionality for all accessor generators */ |
|
32 |
|
33 class AccessorGenerator implements ClassFileConstants { |
|
34 static final Unsafe unsafe = Unsafe.getUnsafe(); |
|
35 |
|
36 // Constants because there's no way to say "short integer constant", |
|
37 // i.e., "1S" |
|
38 protected static final short S0 = (short) 0; |
|
39 protected static final short S1 = (short) 1; |
|
40 protected static final short S2 = (short) 2; |
|
41 protected static final short S3 = (short) 3; |
|
42 protected static final short S4 = (short) 4; |
|
43 protected static final short S5 = (short) 5; |
|
44 protected static final short S6 = (short) 6; |
|
45 |
|
46 // Instance variables for shared functionality between |
|
47 // FieldAccessorGenerator and MethodAccessorGenerator |
|
48 protected ClassFileAssembler asm; |
|
49 protected int modifiers; |
|
50 protected short thisClass; |
|
51 protected short superClass; |
|
52 protected short targetClass; |
|
53 // Common constant pool entries to FieldAccessor and MethodAccessor |
|
54 protected short throwableClass; |
|
55 protected short classCastClass; |
|
56 protected short nullPointerClass; |
|
57 protected short illegalArgumentClass; |
|
58 protected short invocationTargetClass; |
|
59 protected short initIdx; |
|
60 protected short initNameAndTypeIdx; |
|
61 protected short initStringNameAndTypeIdx; |
|
62 protected short nullPointerCtorIdx; |
|
63 protected short illegalArgumentCtorIdx; |
|
64 protected short illegalArgumentStringCtorIdx; |
|
65 protected short invocationTargetCtorIdx; |
|
66 protected short superCtorIdx; |
|
67 protected short objectClass; |
|
68 protected short toStringIdx; |
|
69 protected short codeIdx; |
|
70 protected short exceptionsIdx; |
|
71 // Boxing |
|
72 protected short valueOfIdx; |
|
73 protected short booleanIdx; |
|
74 protected short booleanBoxIdx; |
|
75 protected short booleanUnboxIdx; |
|
76 protected short byteIdx; |
|
77 protected short byteBoxIdx; |
|
78 protected short byteUnboxIdx; |
|
79 protected short characterIdx; |
|
80 protected short characterBoxIdx; |
|
81 protected short characterUnboxIdx; |
|
82 protected short doubleIdx; |
|
83 protected short doubleBoxIdx; |
|
84 protected short doubleUnboxIdx; |
|
85 protected short floatIdx; |
|
86 protected short floatBoxIdx; |
|
87 protected short floatUnboxIdx; |
|
88 protected short integerIdx; |
|
89 protected short integerBoxIdx; |
|
90 protected short integerUnboxIdx; |
|
91 protected short longIdx; |
|
92 protected short longBoxIdx; |
|
93 protected short longUnboxIdx; |
|
94 protected short shortIdx; |
|
95 protected short shortBoxIdx; |
|
96 protected short shortUnboxIdx; |
|
97 |
|
98 protected final short NUM_COMMON_CPOOL_ENTRIES = (short) 30; |
|
99 protected final short NUM_BOXING_CPOOL_ENTRIES = (short) 73; |
|
100 |
|
101 // Requires that superClass has been set up |
|
102 protected void emitCommonConstantPoolEntries() { |
|
103 // + [UTF-8] "java/lang/Throwable" |
|
104 // + [CONSTANT_Class_info] for above |
|
105 // + [UTF-8] "java/lang/ClassCastException" |
|
106 // + [CONSTANT_Class_info] for above |
|
107 // + [UTF-8] "java/lang/NullPointerException" |
|
108 // + [CONSTANT_Class_info] for above |
|
109 // + [UTF-8] "java/lang/IllegalArgumentException" |
|
110 // + [CONSTANT_Class_info] for above |
|
111 // + [UTF-8] "java/lang/InvocationTargetException" |
|
112 // + [CONSTANT_Class_info] for above |
|
113 // + [UTF-8] "<init>" |
|
114 // + [UTF-8] "()V" |
|
115 // + [CONSTANT_NameAndType_info] for above |
|
116 // + [CONSTANT_Methodref_info] for NullPointerException's constructor |
|
117 // + [CONSTANT_Methodref_info] for IllegalArgumentException's constructor |
|
118 // + [UTF-8] "(Ljava/lang/String;)V" |
|
119 // + [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/String;)V" |
|
120 // + [CONSTANT_Methodref_info] for IllegalArgumentException's constructor taking a String |
|
121 // + [UTF-8] "(Ljava/lang/Throwable;)V" |
|
122 // + [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/Throwable;)V" |
|
123 // + [CONSTANT_Methodref_info] for InvocationTargetException's constructor |
|
124 // + [CONSTANT_Methodref_info] for "super()" |
|
125 // + [UTF-8] "java/lang/Object" |
|
126 // + [CONSTANT_Class_info] for above |
|
127 // + [UTF-8] "toString" |
|
128 // + [UTF-8] "()Ljava/lang/String;" |
|
129 // + [CONSTANT_NameAndType_info] for "toString()Ljava/lang/String;" |
|
130 // + [CONSTANT_Methodref_info] for Object's toString method |
|
131 // + [UTF-8] "Code" |
|
132 // + [UTF-8] "Exceptions" |
|
133 asm.emitConstantPoolUTF8("java/lang/Throwable"); |
|
134 asm.emitConstantPoolClass(asm.cpi()); |
|
135 throwableClass = asm.cpi(); |
|
136 asm.emitConstantPoolUTF8("java/lang/ClassCastException"); |
|
137 asm.emitConstantPoolClass(asm.cpi()); |
|
138 classCastClass = asm.cpi(); |
|
139 asm.emitConstantPoolUTF8("java/lang/NullPointerException"); |
|
140 asm.emitConstantPoolClass(asm.cpi()); |
|
141 nullPointerClass = asm.cpi(); |
|
142 asm.emitConstantPoolUTF8("java/lang/IllegalArgumentException"); |
|
143 asm.emitConstantPoolClass(asm.cpi()); |
|
144 illegalArgumentClass = asm.cpi(); |
|
145 asm.emitConstantPoolUTF8("java/lang/reflect/InvocationTargetException"); |
|
146 asm.emitConstantPoolClass(asm.cpi()); |
|
147 invocationTargetClass = asm.cpi(); |
|
148 asm.emitConstantPoolUTF8("<init>"); |
|
149 initIdx = asm.cpi(); |
|
150 asm.emitConstantPoolUTF8("()V"); |
|
151 asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); |
|
152 initNameAndTypeIdx = asm.cpi(); |
|
153 asm.emitConstantPoolMethodref(nullPointerClass, initNameAndTypeIdx); |
|
154 nullPointerCtorIdx = asm.cpi(); |
|
155 asm.emitConstantPoolMethodref(illegalArgumentClass, initNameAndTypeIdx); |
|
156 illegalArgumentCtorIdx = asm.cpi(); |
|
157 asm.emitConstantPoolUTF8("(Ljava/lang/String;)V"); |
|
158 asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); |
|
159 initStringNameAndTypeIdx = asm.cpi(); |
|
160 asm.emitConstantPoolMethodref(illegalArgumentClass, initStringNameAndTypeIdx); |
|
161 illegalArgumentStringCtorIdx = asm.cpi(); |
|
162 asm.emitConstantPoolUTF8("(Ljava/lang/Throwable;)V"); |
|
163 asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); |
|
164 asm.emitConstantPoolMethodref(invocationTargetClass, asm.cpi()); |
|
165 invocationTargetCtorIdx = asm.cpi(); |
|
166 asm.emitConstantPoolMethodref(superClass, initNameAndTypeIdx); |
|
167 superCtorIdx = asm.cpi(); |
|
168 asm.emitConstantPoolUTF8("java/lang/Object"); |
|
169 asm.emitConstantPoolClass(asm.cpi()); |
|
170 objectClass = asm.cpi(); |
|
171 asm.emitConstantPoolUTF8("toString"); |
|
172 asm.emitConstantPoolUTF8("()Ljava/lang/String;"); |
|
173 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
174 asm.emitConstantPoolMethodref(objectClass, asm.cpi()); |
|
175 toStringIdx = asm.cpi(); |
|
176 asm.emitConstantPoolUTF8("Code"); |
|
177 codeIdx = asm.cpi(); |
|
178 asm.emitConstantPoolUTF8("Exceptions"); |
|
179 exceptionsIdx = asm.cpi(); |
|
180 } |
|
181 |
|
182 /** Constant pool entries required to be able to box/unbox primitive |
|
183 types. Note that we don't emit these if we don't need them. */ |
|
184 protected void emitBoxingContantPoolEntries() { |
|
185 // * [UTF-8] "valueOf" |
|
186 // * [UTF-8] "java/lang/Boolean" |
|
187 // * [CONSTANT_Class_info] for above |
|
188 // * [UTF-8] "(Z)Ljava/lang/Boolean;" |
|
189 // * [CONSTANT_NameAndType_info] for above |
|
190 // * [CONSTANT_Methodref_info] for above |
|
191 // * [UTF-8] "booleanValue" |
|
192 // * [UTF-8] "()Z" |
|
193 // * [CONSTANT_NameAndType_info] for above |
|
194 // * [CONSTANT_Methodref_info] for above |
|
195 // * [UTF-8] "java/lang/Byte" |
|
196 // * [CONSTANT_Class_info] for above |
|
197 // * [UTF-8] "(B)Ljava/lang/Byte;" |
|
198 // * [CONSTANT_NameAndType_info] for above |
|
199 // * [CONSTANT_Methodref_info] for above |
|
200 // * [UTF-8] "byteValue" |
|
201 // * [UTF-8] "()B" |
|
202 // * [CONSTANT_NameAndType_info] for above |
|
203 // * [CONSTANT_Methodref_info] for above |
|
204 // * [UTF-8] "java/lang/Character" |
|
205 // * [CONSTANT_Class_info] for above |
|
206 // * [UTF-8] "(C)Ljava/lang/Character;" |
|
207 // * [CONSTANT_NameAndType_info] for above |
|
208 // * [CONSTANT_Methodref_info] for above |
|
209 // * [UTF-8] "charValue" |
|
210 // * [UTF-8] "()C" |
|
211 // * [CONSTANT_NameAndType_info] for above |
|
212 // * [CONSTANT_Methodref_info] for above |
|
213 // * [UTF-8] "java/lang/Double" |
|
214 // * [CONSTANT_Class_info] for above |
|
215 // * [UTF-8] "(D)Ljava/lang/Double;" |
|
216 // * [CONSTANT_NameAndType_info] for above |
|
217 // * [CONSTANT_Methodref_info] for above |
|
218 // * [UTF-8] "doubleValue" |
|
219 // * [UTF-8] "()D" |
|
220 // * [CONSTANT_NameAndType_info] for above |
|
221 // * [CONSTANT_Methodref_info] for above |
|
222 // * [UTF-8] "java/lang/Float" |
|
223 // * [CONSTANT_Class_info] for above |
|
224 // * [UTF-8] "(F)Ljava/lang/Float;" |
|
225 // * [CONSTANT_NameAndType_info] for above |
|
226 // * [CONSTANT_Methodref_info] for above |
|
227 // * [UTF-8] "floatValue" |
|
228 // * [UTF-8] "()F" |
|
229 // * [CONSTANT_NameAndType_info] for above |
|
230 // * [CONSTANT_Methodref_info] for above |
|
231 // * [UTF-8] "java/lang/Integer" |
|
232 // * [CONSTANT_Class_info] for above |
|
233 // * [UTF-8] "(I)Ljava/lang/Integer;" |
|
234 // * [CONSTANT_NameAndType_info] for above |
|
235 // * [CONSTANT_Methodref_info] for above |
|
236 // * [UTF-8] "intValue" |
|
237 // * [UTF-8] "()I" |
|
238 // * [CONSTANT_NameAndType_info] for above |
|
239 // * [CONSTANT_Methodref_info] for above |
|
240 // * [UTF-8] "java/lang/Long" |
|
241 // * [CONSTANT_Class_info] for above |
|
242 // * [UTF-8] "(J)Ljava/lang/Long;" |
|
243 // * [CONSTANT_NameAndType_info] for above |
|
244 // * [CONSTANT_Methodref_info] for above |
|
245 // * [UTF-8] "longValue" |
|
246 // * [UTF-8] "()J" |
|
247 // * [CONSTANT_NameAndType_info] for above |
|
248 // * [CONSTANT_Methodref_info] for above |
|
249 // * [UTF-8] "java/lang/Short" |
|
250 // * [CONSTANT_Class_info] for above |
|
251 // * [UTF-8] "(S)Ljava/lang/Short;" |
|
252 // * [CONSTANT_NameAndType_info] for above |
|
253 // * [CONSTANT_Methodref_info] for above |
|
254 // * [UTF-8] "shortValue" |
|
255 // * [UTF-8] "()S" |
|
256 // * [CONSTANT_NameAndType_info] for above |
|
257 // * [CONSTANT_Methodref_info] for above |
|
258 |
|
259 // valueOf-method name |
|
260 asm.emitConstantPoolUTF8("valueOf"); |
|
261 valueOfIdx = asm.cpi(); |
|
262 |
|
263 // Boolean |
|
264 asm.emitConstantPoolUTF8("java/lang/Boolean"); |
|
265 asm.emitConstantPoolClass(asm.cpi()); |
|
266 booleanIdx = asm.cpi(); |
|
267 asm.emitConstantPoolUTF8("(Z)Ljava/lang/Boolean;"); |
|
268 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
269 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
270 booleanBoxIdx = asm.cpi(); |
|
271 asm.emitConstantPoolUTF8("booleanValue"); |
|
272 asm.emitConstantPoolUTF8("()Z"); |
|
273 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
274 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
275 booleanUnboxIdx = asm.cpi(); |
|
276 |
|
277 // Byte |
|
278 asm.emitConstantPoolUTF8("java/lang/Byte"); |
|
279 asm.emitConstantPoolClass(asm.cpi()); |
|
280 byteIdx = asm.cpi(); |
|
281 asm.emitConstantPoolUTF8("(B)Ljava/lang/Byte;"); |
|
282 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
283 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
284 byteBoxIdx = asm.cpi(); |
|
285 asm.emitConstantPoolUTF8("byteValue"); |
|
286 asm.emitConstantPoolUTF8("()B"); |
|
287 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
288 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
289 byteUnboxIdx = asm.cpi(); |
|
290 |
|
291 // Character |
|
292 asm.emitConstantPoolUTF8("java/lang/Character"); |
|
293 asm.emitConstantPoolClass(asm.cpi()); |
|
294 characterIdx = asm.cpi(); |
|
295 asm.emitConstantPoolUTF8("(C)Ljava/lang/Character;"); |
|
296 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
297 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
298 characterBoxIdx = asm.cpi(); |
|
299 asm.emitConstantPoolUTF8("charValue"); |
|
300 asm.emitConstantPoolUTF8("()C"); |
|
301 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
302 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
303 characterUnboxIdx = asm.cpi(); |
|
304 |
|
305 // Double |
|
306 asm.emitConstantPoolUTF8("java/lang/Double"); |
|
307 asm.emitConstantPoolClass(asm.cpi()); |
|
308 doubleIdx = asm.cpi(); |
|
309 asm.emitConstantPoolUTF8("(D)Ljava/lang/Double;"); |
|
310 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
311 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
312 doubleBoxIdx = asm.cpi(); |
|
313 asm.emitConstantPoolUTF8("doubleValue"); |
|
314 asm.emitConstantPoolUTF8("()D"); |
|
315 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
316 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
317 doubleUnboxIdx = asm.cpi(); |
|
318 |
|
319 // Float |
|
320 asm.emitConstantPoolUTF8("java/lang/Float"); |
|
321 asm.emitConstantPoolClass(asm.cpi()); |
|
322 floatIdx = asm.cpi(); |
|
323 asm.emitConstantPoolUTF8("(F)Ljava/lang/Float;"); |
|
324 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
325 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
326 floatBoxIdx = asm.cpi(); |
|
327 asm.emitConstantPoolUTF8("floatValue"); |
|
328 asm.emitConstantPoolUTF8("()F"); |
|
329 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
330 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
331 floatUnboxIdx = asm.cpi(); |
|
332 |
|
333 // Integer |
|
334 asm.emitConstantPoolUTF8("java/lang/Integer"); |
|
335 asm.emitConstantPoolClass(asm.cpi()); |
|
336 integerIdx = asm.cpi(); |
|
337 asm.emitConstantPoolUTF8("(I)Ljava/lang/Integer;"); |
|
338 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
339 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
340 integerBoxIdx = asm.cpi(); |
|
341 asm.emitConstantPoolUTF8("intValue"); |
|
342 asm.emitConstantPoolUTF8("()I"); |
|
343 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
344 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
345 integerUnboxIdx = asm.cpi(); |
|
346 |
|
347 // Long |
|
348 asm.emitConstantPoolUTF8("java/lang/Long"); |
|
349 asm.emitConstantPoolClass(asm.cpi()); |
|
350 longIdx = asm.cpi(); |
|
351 asm.emitConstantPoolUTF8("(J)Ljava/lang/Long;"); |
|
352 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
353 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
354 longBoxIdx = asm.cpi(); |
|
355 asm.emitConstantPoolUTF8("longValue"); |
|
356 asm.emitConstantPoolUTF8("()J"); |
|
357 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
358 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
359 longUnboxIdx = asm.cpi(); |
|
360 |
|
361 // Short |
|
362 asm.emitConstantPoolUTF8("java/lang/Short"); |
|
363 asm.emitConstantPoolClass(asm.cpi()); |
|
364 shortIdx = asm.cpi(); |
|
365 asm.emitConstantPoolUTF8("(S)Ljava/lang/Short;"); |
|
366 asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); |
|
367 asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); |
|
368 shortBoxIdx = asm.cpi(); |
|
369 asm.emitConstantPoolUTF8("shortValue"); |
|
370 asm.emitConstantPoolUTF8("()S"); |
|
371 asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); |
|
372 asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); |
|
373 shortUnboxIdx = asm.cpi(); |
|
374 } |
|
375 |
|
376 // Necessary because of Java's annoying promotion rules |
|
377 protected static short add(short s1, short s2) { |
|
378 return (short) (s1 + s2); |
|
379 } |
|
380 |
|
381 protected static short sub(short s1, short s2) { |
|
382 return (short) (s1 - s2); |
|
383 } |
|
384 |
|
385 protected boolean isStatic() { |
|
386 return Modifier.isStatic(modifiers); |
|
387 } |
|
388 |
|
389 protected boolean isPrivate() { |
|
390 return Modifier.isPrivate(modifiers); |
|
391 } |
|
392 |
|
393 /** Returns class name in "internal" form (i.e., '/' separators |
|
394 instead of '.') */ |
|
395 protected static String getClassName |
|
396 (Class<?> c, boolean addPrefixAndSuffixForNonPrimitiveTypes) |
|
397 { |
|
398 if (c.isPrimitive()) { |
|
399 if (c == Boolean.TYPE) { |
|
400 return "Z"; |
|
401 } else if (c == Byte.TYPE) { |
|
402 return "B"; |
|
403 } else if (c == Character.TYPE) { |
|
404 return "C"; |
|
405 } else if (c == Double.TYPE) { |
|
406 return "D"; |
|
407 } else if (c == Float.TYPE) { |
|
408 return "F"; |
|
409 } else if (c == Integer.TYPE) { |
|
410 return "I"; |
|
411 } else if (c == Long.TYPE) { |
|
412 return "J"; |
|
413 } else if (c == Short.TYPE) { |
|
414 return "S"; |
|
415 } else if (c == Void.TYPE) { |
|
416 return "V"; |
|
417 } |
|
418 throw new InternalError("Should have found primitive type"); |
|
419 } else if (c.isArray()) { |
|
420 return "[" + getClassName(c.getComponentType(), true); |
|
421 } else { |
|
422 if (addPrefixAndSuffixForNonPrimitiveTypes) { |
|
423 return internalize("L" + c.getName() + ";"); |
|
424 } else { |
|
425 return internalize(c.getName()); |
|
426 } |
|
427 } |
|
428 } |
|
429 |
|
430 private static String internalize(String className) { |
|
431 return className.replace('.', '/'); |
|
432 } |
|
433 |
|
434 protected void emitConstructor() { |
|
435 // Generate code into fresh code buffer |
|
436 ClassFileAssembler cb = new ClassFileAssembler(); |
|
437 // 0 incoming arguments |
|
438 cb.setMaxLocals(1); |
|
439 cb.opc_aload_0(); |
|
440 cb.opc_invokespecial(superCtorIdx, 0, 0); |
|
441 cb.opc_return(); |
|
442 |
|
443 // Emit method |
|
444 emitMethod(initIdx, cb.getMaxLocals(), cb, null, null); |
|
445 } |
|
446 |
|
447 // The descriptor's index in the constant pool must be (1 + |
|
448 // nameIdx). "numArgs" must indicate ALL arguments, including the |
|
449 // implicit "this" argument; double and long arguments each count |
|
450 // as 2 in this count. The code buffer must NOT contain the code |
|
451 // length. The exception table may be null, but if non-null must |
|
452 // NOT contain the exception table's length. The checked exception |
|
453 // indices may be null. |
|
454 protected void emitMethod(short nameIdx, |
|
455 int numArgs, |
|
456 ClassFileAssembler code, |
|
457 ClassFileAssembler exceptionTable, |
|
458 short[] checkedExceptionIndices) |
|
459 { |
|
460 int codeLen = code.getLength(); |
|
461 int excLen = 0; |
|
462 if (exceptionTable != null) { |
|
463 excLen = exceptionTable.getLength(); |
|
464 if ((excLen % 8) != 0) { |
|
465 throw new IllegalArgumentException("Illegal exception table"); |
|
466 } |
|
467 } |
|
468 int attrLen = 12 + codeLen + excLen; |
|
469 excLen = excLen / 8; // No-op if no exception table |
|
470 |
|
471 asm.emitShort(ACC_PUBLIC); |
|
472 asm.emitShort(nameIdx); |
|
473 asm.emitShort(add(nameIdx, S1)); |
|
474 if (checkedExceptionIndices == null) { |
|
475 // Code attribute only |
|
476 asm.emitShort(S1); |
|
477 } else { |
|
478 // Code and Exceptions attributes |
|
479 asm.emitShort(S2); |
|
480 } |
|
481 // Code attribute |
|
482 asm.emitShort(codeIdx); |
|
483 asm.emitInt(attrLen); |
|
484 asm.emitShort(code.getMaxStack()); |
|
485 asm.emitShort((short) Math.max(numArgs, code.getMaxLocals())); |
|
486 asm.emitInt(codeLen); |
|
487 asm.append(code); |
|
488 asm.emitShort((short) excLen); |
|
489 if (exceptionTable != null) { |
|
490 asm.append(exceptionTable); |
|
491 } |
|
492 asm.emitShort(S0); // No additional attributes for Code attribute |
|
493 if (checkedExceptionIndices != null) { |
|
494 // Exceptions attribute |
|
495 asm.emitShort(exceptionsIdx); |
|
496 asm.emitInt(2 + 2 * checkedExceptionIndices.length); |
|
497 asm.emitShort((short) checkedExceptionIndices.length); |
|
498 for (int i = 0; i < checkedExceptionIndices.length; i++) { |
|
499 asm.emitShort(checkedExceptionIndices[i]); |
|
500 } |
|
501 } |
|
502 } |
|
503 |
|
504 protected short indexForPrimitiveType(Class<?> type) { |
|
505 if (type == Boolean.TYPE) { |
|
506 return booleanIdx; |
|
507 } else if (type == Byte.TYPE) { |
|
508 return byteIdx; |
|
509 } else if (type == Character.TYPE) { |
|
510 return characterIdx; |
|
511 } else if (type == Double.TYPE) { |
|
512 return doubleIdx; |
|
513 } else if (type == Float.TYPE) { |
|
514 return floatIdx; |
|
515 } else if (type == Integer.TYPE) { |
|
516 return integerIdx; |
|
517 } else if (type == Long.TYPE) { |
|
518 return longIdx; |
|
519 } else if (type == Short.TYPE) { |
|
520 return shortIdx; |
|
521 } |
|
522 throw new InternalError("Should have found primitive type"); |
|
523 } |
|
524 |
|
525 protected short boxingMethodForPrimitiveType(Class<?> type) { |
|
526 if (type == Boolean.TYPE) { |
|
527 return booleanBoxIdx; |
|
528 } else if (type == Byte.TYPE) { |
|
529 return byteBoxIdx; |
|
530 } else if (type == Character.TYPE) { |
|
531 return characterBoxIdx; |
|
532 } else if (type == Double.TYPE) { |
|
533 return doubleBoxIdx; |
|
534 } else if (type == Float.TYPE) { |
|
535 return floatBoxIdx; |
|
536 } else if (type == Integer.TYPE) { |
|
537 return integerBoxIdx; |
|
538 } else if (type == Long.TYPE) { |
|
539 return longBoxIdx; |
|
540 } else if (type == Short.TYPE) { |
|
541 return shortBoxIdx; |
|
542 } |
|
543 throw new InternalError("Should have found primitive type"); |
|
544 } |
|
545 |
|
546 /** Returns true for widening or identity conversions for primitive |
|
547 types only */ |
|
548 protected static boolean canWidenTo(Class<?> type, Class<?> otherType) { |
|
549 if (!type.isPrimitive()) { |
|
550 return false; |
|
551 } |
|
552 |
|
553 // Widening conversions (from JVM spec): |
|
554 // byte to short, int, long, float, or double |
|
555 // short to int, long, float, or double |
|
556 // char to int, long, float, or double |
|
557 // int to long, float, or double |
|
558 // long to float or double |
|
559 // float to double |
|
560 |
|
561 if (type == Boolean.TYPE) { |
|
562 if (otherType == Boolean.TYPE) { |
|
563 return true; |
|
564 } |
|
565 } else if (type == Byte.TYPE) { |
|
566 if ( otherType == Byte.TYPE |
|
567 || otherType == Short.TYPE |
|
568 || otherType == Integer.TYPE |
|
569 || otherType == Long.TYPE |
|
570 || otherType == Float.TYPE |
|
571 || otherType == Double.TYPE) { |
|
572 return true; |
|
573 } |
|
574 } else if (type == Short.TYPE) { |
|
575 if ( otherType == Short.TYPE |
|
576 || otherType == Integer.TYPE |
|
577 || otherType == Long.TYPE |
|
578 || otherType == Float.TYPE |
|
579 || otherType == Double.TYPE) { |
|
580 return true; |
|
581 } |
|
582 } else if (type == Character.TYPE) { |
|
583 if ( otherType == Character.TYPE |
|
584 || otherType == Integer.TYPE |
|
585 || otherType == Long.TYPE |
|
586 || otherType == Float.TYPE |
|
587 || otherType == Double.TYPE) { |
|
588 return true; |
|
589 } |
|
590 } else if (type == Integer.TYPE) { |
|
591 if ( otherType == Integer.TYPE |
|
592 || otherType == Long.TYPE |
|
593 || otherType == Float.TYPE |
|
594 || otherType == Double.TYPE) { |
|
595 return true; |
|
596 } |
|
597 } else if (type == Long.TYPE) { |
|
598 if ( otherType == Long.TYPE |
|
599 || otherType == Float.TYPE |
|
600 || otherType == Double.TYPE) { |
|
601 return true; |
|
602 } |
|
603 } else if (type == Float.TYPE) { |
|
604 if ( otherType == Float.TYPE |
|
605 || otherType == Double.TYPE) { |
|
606 return true; |
|
607 } |
|
608 } else if (type == Double.TYPE) { |
|
609 if (otherType == Double.TYPE) { |
|
610 return true; |
|
611 } |
|
612 } |
|
613 |
|
614 return false; |
|
615 } |
|
616 |
|
617 /** Emits the widening bytecode for the given primitive conversion |
|
618 (or none if the identity conversion). Requires that a primitive |
|
619 conversion exists; i.e., canWidenTo must have already been |
|
620 called and returned true. */ |
|
621 protected static void emitWideningBytecodeForPrimitiveConversion |
|
622 (ClassFileAssembler cb, |
|
623 Class<?> fromType, |
|
624 Class<?> toType) |
|
625 { |
|
626 // Note that widening conversions for integral types (i.e., "b2s", |
|
627 // "s2i") are no-ops since values on the Java stack are |
|
628 // sign-extended. |
|
629 |
|
630 // Widening conversions (from JVM spec): |
|
631 // byte to short, int, long, float, or double |
|
632 // short to int, long, float, or double |
|
633 // char to int, long, float, or double |
|
634 // int to long, float, or double |
|
635 // long to float or double |
|
636 // float to double |
|
637 |
|
638 if ( fromType == Byte.TYPE |
|
639 || fromType == Short.TYPE |
|
640 || fromType == Character.TYPE |
|
641 || fromType == Integer.TYPE) { |
|
642 if (toType == Long.TYPE) { |
|
643 cb.opc_i2l(); |
|
644 } else if (toType == Float.TYPE) { |
|
645 cb.opc_i2f(); |
|
646 } else if (toType == Double.TYPE) { |
|
647 cb.opc_i2d(); |
|
648 } |
|
649 } else if (fromType == Long.TYPE) { |
|
650 if (toType == Float.TYPE) { |
|
651 cb.opc_l2f(); |
|
652 } else if (toType == Double.TYPE) { |
|
653 cb.opc_l2d(); |
|
654 } |
|
655 } else if (fromType == Float.TYPE) { |
|
656 if (toType == Double.TYPE) { |
|
657 cb.opc_f2d(); |
|
658 } |
|
659 } |
|
660 |
|
661 // Otherwise, was identity or no-op conversion. Fall through. |
|
662 } |
|
663 |
|
664 protected short unboxingMethodForPrimitiveType(Class<?> primType) { |
|
665 if (primType == Boolean.TYPE) { |
|
666 return booleanUnboxIdx; |
|
667 } else if (primType == Byte.TYPE) { |
|
668 return byteUnboxIdx; |
|
669 } else if (primType == Character.TYPE) { |
|
670 return characterUnboxIdx; |
|
671 } else if (primType == Short.TYPE) { |
|
672 return shortUnboxIdx; |
|
673 } else if (primType == Integer.TYPE) { |
|
674 return integerUnboxIdx; |
|
675 } else if (primType == Long.TYPE) { |
|
676 return longUnboxIdx; |
|
677 } else if (primType == Float.TYPE) { |
|
678 return floatUnboxIdx; |
|
679 } else if (primType == Double.TYPE) { |
|
680 return doubleUnboxIdx; |
|
681 } |
|
682 throw new InternalError("Illegal primitive type " + primType.getName()); |
|
683 } |
|
684 |
|
685 protected static final Class<?>[] primitiveTypes = new Class<?>[] { |
|
686 Boolean.TYPE, |
|
687 Byte.TYPE, |
|
688 Character.TYPE, |
|
689 Short.TYPE, |
|
690 Integer.TYPE, |
|
691 Long.TYPE, |
|
692 Float.TYPE, |
|
693 Double.TYPE |
|
694 }; |
|
695 |
|
696 /** We don't consider "Void" to be a primitive type */ |
|
697 protected static boolean isPrimitive(Class<?> c) { |
|
698 return (c.isPrimitive() && c != Void.TYPE); |
|
699 } |
|
700 |
|
701 protected int typeSizeInStackSlots(Class<?> c) { |
|
702 if (c == Void.TYPE) { |
|
703 return 0; |
|
704 } |
|
705 if (c == Long.TYPE || c == Double.TYPE) { |
|
706 return 2; |
|
707 } |
|
708 return 1; |
|
709 } |
|
710 |
|
711 private ClassFileAssembler illegalArgumentCodeBuffer; |
|
712 protected ClassFileAssembler illegalArgumentCodeBuffer() { |
|
713 if (illegalArgumentCodeBuffer == null) { |
|
714 illegalArgumentCodeBuffer = new ClassFileAssembler(); |
|
715 illegalArgumentCodeBuffer.opc_new(illegalArgumentClass); |
|
716 illegalArgumentCodeBuffer.opc_dup(); |
|
717 illegalArgumentCodeBuffer.opc_invokespecial(illegalArgumentCtorIdx, 0, 0); |
|
718 illegalArgumentCodeBuffer.opc_athrow(); |
|
719 } |
|
720 |
|
721 return illegalArgumentCodeBuffer; |
|
722 } |
|
723 } |
|