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 sun.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 }