1 /*
2 * Copyright (c) 2002, 2012, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package sun.jvm.hotspot.utilities;
26
27 import java.lang.reflect.Modifier;
28 import java.util.*;
29 import java.util.stream.*;
30 import sun.jvm.hotspot.debugger.*;
31 import sun.jvm.hotspot.oops.*;
32 import sun.jvm.hotspot.runtime.*;
33 import sun.jvm.hotspot.utilities.*;
34
35 /**
36 * ObjectReader can "deserialize" objects from debuggee.
37 *
38 * Class Loading:
39 *
40 * ObjectReader loads classes using the given class loader. If no
41 * class loader is supplied, it uses a ProcImageClassLoader, which
42 * loads classes from debuggee core or process.
43
44 * Object creation:
45 *
46 * This class uses no-arg constructor to construct objects. But if
47 * there is no no-arg constructor in a given class, then it tries to
48 * use other constructors with 'default' values - null for object
49 * types, 0, 0.0, false etc. for primitives. If this process fails to
50 * construct an instance (because of null checking by constructor or 0
51 * being invalid for an int arg etc.), then null is returned. While
52 * constructing complete object graph 'null' is inserted silently on
53 * failure and the deserialization continues to construct best-effort
54 * object graph.
55 *
56 * Debug messages:
57 *
58 * The flag sun.jvm.hotspot.utilities.ObjectReader.DEBUG may be set to
59 * non-null to get debug error messages and stack traces.
60 *
61 * JDK version:
62 *
63 * JDK classes are loaded by bootstrap class loader and not by the
64 * supplied class loader or ProcImageClassLoader. This may create
65 * problems if a JDK class evolves. i.e., if SA runs a JDK version
66 * different from that of the debuggee, there is a possibility of
67 * schema change. It is recommended that the matching JDK version be
68 * used to run SA for proper object deserialization.
69 *
70 */
71
72 public class ObjectReader {
73
74 private static final boolean DEBUG;
75 static {
76 DEBUG = System.getProperty("sun.jvm.hotspot.utilities.ObjectReader.DEBUG") != null;
77 }
78
79 public ObjectReader(ClassLoader cl) {
80 this.cl = cl;
81 this.oopToObjMap = new HashMap();
82 this.fieldMap = new HashMap();
83 }
84
85 public ObjectReader() {
86 this(new ProcImageClassLoader());
87 }
88
89 static void debugPrintln(String msg) {
90 if (DEBUG) {
91 System.err.println("DEBUG>" + msg);
92 }
93 }
94
95 static void debugPrintStackTrace(Exception exp) {
96 if (DEBUG) {
97 StackTraceElement[] els = exp.getStackTrace();
98 for (int i = 0; i < els.length; i++) {
99 System.err.println("DEBUG>" + els[i].toString());
100 }
101 }
102 }
103
104 public Object readObject(Oop oop) throws ClassNotFoundException {
105 if (oop instanceof Instance) {
106 return readInstance((Instance) oop);
107 } else if (oop instanceof TypeArray){
108 return readPrimitiveArray((TypeArray)oop);
109 } else if (oop instanceof ObjArray){
110 return readObjectArray((ObjArray)oop);
111 } else {
112 return null;
113 }
114 }
115
116 protected final Object getDefaultPrimitiveValue(Class clz) {
117 if (clz == Boolean.TYPE) {
118 return Boolean.FALSE;
119 } else if (clz == Character.TYPE) {
120 return new Character(' ');
121 } else if (clz == Byte.TYPE) {
122 return new Byte((byte) 0);
123 } else if (clz == Short.TYPE) {
124 return new Short((short) 0);
125 } else if (clz == Integer.TYPE) {
126 return new Integer(0);
127 } else if (clz == Long.TYPE) {
128 return new Long(0L);
129 } else if (clz == Float.TYPE) {
130 return new Float(0.0f);
131 } else if (clz == Double.TYPE) {
132 return new Double(0.0);
133 } else {
134 throw new RuntimeException("should not reach here!");
135 }
136 }
137
138 protected Symbol javaLangString;
139 protected Symbol javaUtilHashtableEntry;
140 protected Symbol javaUtilHashtable;
141 protected Symbol javaUtilProperties;
142
143 protected Symbol getVMSymbol(String name) {
144 return VM.getVM().getSymbolTable().probe(name);
145 }
146
147 protected Symbol javaLangString() {
148 if (javaLangString == null) {
149 javaLangString = getVMSymbol("java/lang/String");
150 }
151 return javaLangString;
152 }
153
154 protected Symbol javaUtilHashtableEntry() {
155 if (javaUtilHashtableEntry == null) {
156 javaUtilHashtableEntry = getVMSymbol("java/util/Hashtable$Entry");
157 }
158 return javaUtilHashtableEntry;
159 }
160
161 protected Symbol javaUtilHashtable() {
162 if (javaUtilHashtable == null) {
163 javaUtilHashtable = getVMSymbol("java/util/Hashtable");
164 }
165 return javaUtilHashtable;
166 }
167
168 protected Symbol javaUtilProperties() {
169 if (javaUtilProperties == null) {
170 javaUtilProperties = getVMSymbol("java/util/Properties");
171 }
172 return javaUtilProperties;
173 }
174
175 private void setHashtableEntry(java.util.Hashtable p, Oop oop) {
176 InstanceKlass ik = (InstanceKlass)oop.getKlass();
177 OopField keyField = (OopField)ik.findField("key", "Ljava/lang/Object;");
178 OopField valueField = (OopField)ik.findField("value", "Ljava/lang/Object;");
179 OopField nextField = (OopField)ik.findField("next", "Ljava/util/Hashtable$Entry;");
180 if (DEBUG) {
181 if (Assert.ASSERTS_ENABLED) {
182 Assert.that(ik.getName().equals(javaUtilHashtableEntry()), "Not a Hashtable$Entry?");
183 Assert.that(keyField != null && valueField != null && nextField != null, "Invalid fields!");
184 }
185 }
186
187 Object key = null;
188 Object value = null;
189 Oop next = null;
190 try {
191 key = readObject(keyField.getValue(oop));
192 value = readObject(valueField.getValue(oop));
193 next = (Oop)nextField.getValue(oop);
194 // For Properties, should use setProperty(k, v). Since it only runs in SA
195 // using put(k, v) should be OK.
196 p.put(key, value);
197 if (next != null) {
198 setHashtableEntry(p, next);
199 }
200 } catch (ClassNotFoundException ce) {
201 if( DEBUG) {
202 debugPrintln("Class not found " + ce);
203 debugPrintStackTrace(ce);
204 }
205 }
206 }
207
208 private void setPropertiesEntry(java.util.Properties p, Oop oop) {
209 InstanceKlass ik = (InstanceKlass)oop.getKlass();
210 OopField keyField = (OopField)ik.findField("key", "Ljava/lang/Object;");
211 OopField valueField = (OopField)ik.findField("val", "Ljava/lang/Object;");
212
213 try {
214 p.setProperty((String)readObject(keyField.getValue(oop)),
215 (String)readObject(valueField.getValue(oop)));
216 } catch (ClassNotFoundException ce) {
217 if (DEBUG) {
218 debugPrintStackTrace(ce);
219 }
220 }
221 }
222
223 protected Object getHashtable(Instance oop) {
224 InstanceKlass k = (InstanceKlass)oop.getKlass();
225 OopField tableField = (OopField)k.findField("table", "[Ljava/util/Hashtable$Entry;");
226 if (tableField == null) {
227 debugPrintln("Could not find field of [Ljava/util/Hashtable$Entry;");
228 return null;
229 }
230 java.util.Hashtable table = new java.util.Hashtable();
231 ObjArray kvs = (ObjArray)tableField.getValue(oop);
232 long size = kvs.getLength();
233 debugPrintln("Hashtable$Entry Size = " + size);
234 for (long i=0; i<size; i++) {
235 Oop entry = kvs.getObjAt(i);
236 if (entry != null && entry.isInstance()) {
237 setHashtableEntry(table, entry);
238 }
239 }
240 return table;
241 }
242
243 private Properties getProperties(Instance oop) {
244 InstanceKlass k = (InstanceKlass)oop.getKlass();
245 OopField mapField = (OopField)k.findField("map", "Ljava/util/concurrent/ConcurrentHashMap;");
246 if (mapField == null) {
247 debugPrintln("Could not find field of Ljava/util/concurrent/ConcurrentHashMap");
248 return null;
249 }
250
251 Instance mapObj = (Instance)mapField.getValue(oop);
252 if (mapObj == null) {
253 debugPrintln("Could not get map field from java.util.Properties");
254 return null;
255 }
256
257 InstanceKlass mk = (InstanceKlass)mapObj.getKlass();
258 OopField tableField = (OopField)mk.findField("table", "[Ljava/util/concurrent/ConcurrentHashMap$Node;");
259 if (tableField == null) {
260 debugPrintln("Could not find field of [Ljava/util/concurrent/ConcurrentHashMap$Node");
261 return null;
262 }
263
264 java.util.Properties props = new java.util.Properties();
265 ObjArray kvs = (ObjArray)tableField.getValue(mapObj);
266 long size = kvs.getLength();
267 debugPrintln("ConcurrentHashMap$Node Size = " + size);
268 LongStream.range(0, size)
269 .mapToObj(kvs::getObjAt)
270 .filter(o -> o != null)
271 .forEach(o -> setPropertiesEntry(props, o));
272
273 return props;
274 }
275
276 public Object readInstance(Instance oop) throws ClassNotFoundException {
277 Object result = getFromObjTable(oop);
278 if (result == null) {
279 InstanceKlass kls = (InstanceKlass) oop.getKlass();
280 // Handle java.lang.String instances differently. As part of JSR-133, fields of immutable
281 // classes have been made final. The algorithm below will not be able to read Strings from
282 // debuggee (can't use reflection to set final fields). But, need to read Strings is very
283 // important.
284 // Same for Hashtable, key and hash are final, could not be set in the algorithm too.
285 // FIXME: need a framework to handle many other special cases.
286 if (kls.getName().equals(javaLangString())) {
287 return OopUtilities.stringOopToString(oop);
288 }
289
290 if (kls.getName().equals(javaUtilHashtable())) {
291 return getHashtable(oop);
292 }
293
294 if (kls.getName().equals(javaUtilProperties())) {
295 return getProperties(oop);
296 }
297
298 Class clz = readClass(kls);
299 try {
300 result = clz.newInstance();
301 } catch (Exception ex) {
302 // no-arg constructor failed to create object. Let us try
303 // to call constructors one-by-one with default arguments
304 // (null for objects, 0/0.0 etc. for primitives) till we
305 // succeed or fail on all constructors.
306
307 java.lang.reflect.Constructor[] ctrs = clz.getDeclaredConstructors();
308 for (int n = 0; n < ctrs.length; n++) {
309 java.lang.reflect.Constructor c = ctrs[n];
310 Class[] paramTypes = c.getParameterTypes();
311 Object[] params = new Object[paramTypes.length];
312 for (int i = 0; i < params.length; i++) {
313 if (paramTypes[i].isPrimitive()) {
314 params[i] = getDefaultPrimitiveValue(paramTypes[i]);
315 }
316 }
317 try {
318 c.setAccessible(true);
319 result = c.newInstance(params);
320 break;
321 } catch (Exception exp) {
322 if (DEBUG) {
323 debugPrintln("Can't create object using " + c);
324 debugPrintStackTrace(exp);
325 }
326 }
327 }
328 }
329
330 if (result != null) {
331 putIntoObjTable(oop, result);
332 oop.iterate(new FieldSetter(result), false);
333 }
334 }
335 return result;
336 }
337
338 public Object readPrimitiveArray(final TypeArray array) {
339
340 Object result = getFromObjTable(array);
341 if (result == null) {
342 int length = (int) array.getLength();
343 TypeArrayKlass klass = (TypeArrayKlass) array.getKlass();
344 int type = (int) klass.getElementType();
345 switch (type) {
346 case TypeArrayKlass.T_BOOLEAN: {
347 final boolean[] arrayObj = new boolean[length];
348 array.iterate(new DefaultOopVisitor() {
349 public void doBoolean(BooleanField field, boolean isVMField) {
350 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
351 arrayObj[ifd.getIndex()] = field.getValue(array);
352 }
353 }, false);
354 result = arrayObj;
355 }
356 break;
357
358 case TypeArrayKlass.T_CHAR: {
359 final char[] arrayObj = new char[length];
360 array.iterate(new DefaultOopVisitor() {
361 public void doChar(CharField field, boolean isVMField) {
362 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
363 arrayObj[ifd.getIndex()] = field.getValue(array);
364 }
365 }, false);
366 result = arrayObj;
367 }
368 break;
369
370 case TypeArrayKlass.T_FLOAT: {
371 final float[] arrayObj = new float[length];
372 array.iterate(new DefaultOopVisitor() {
373 public void doFloat(FloatField field, boolean isVMField) {
374 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
375 arrayObj[ifd.getIndex()] = field.getValue(array);
376 }
377 }, false);
378 result = arrayObj;
379 }
380 break;
381
382 case TypeArrayKlass.T_DOUBLE: {
383 final double[] arrayObj = new double[length];
384 array.iterate(new DefaultOopVisitor() {
385 public void doDouble(DoubleField field, boolean isVMField) {
386 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
387 arrayObj[ifd.getIndex()] = field.getValue(array);
388 }
389 }, false);
390 result = arrayObj;
391 }
392 break;
393
394 case TypeArrayKlass.T_BYTE: {
395 final byte[] arrayObj = new byte[length];
396 array.iterate(new DefaultOopVisitor() {
397 public void doByte(ByteField field, boolean isVMField) {
398 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
399 arrayObj[ifd.getIndex()] = field.getValue(array);
400 }
401 }, false);
402 result = arrayObj;
403 }
404 break;
405
406 case TypeArrayKlass.T_SHORT: {
407 final short[] arrayObj = new short[length];
408 array.iterate(new DefaultOopVisitor() {
409 public void doShort(ShortField field, boolean isVMField) {
410 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
411 arrayObj[ifd.getIndex()] = field.getValue(array);
412 }
413 }, false);
414 result = arrayObj;
415 }
416 break;
417
418 case TypeArrayKlass.T_INT: {
419 final int[] arrayObj = new int[length];
420 array.iterate(new DefaultOopVisitor() {
421 public void doInt(IntField field, boolean isVMField) {
422 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
423 arrayObj[ifd.getIndex()] = field.getValue(array);
424 }
425 }, false);
426 result = arrayObj;
427 }
428 break;
429
430 case TypeArrayKlass.T_LONG: {
431 final long[] arrayObj = new long[length];
432 array.iterate(new DefaultOopVisitor() {
433 public void doLong(LongField field, boolean isVMField) {
434 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
435 arrayObj[ifd.getIndex()] = field.getValue(array);
436 }
437 }, false);
438 result = arrayObj;
439 }
440 break;
441
442 default:
443 throw new RuntimeException("should not reach here!");
444 }
445
446 putIntoObjTable(array, result);
447 }
448 return result;
449 }
450
451 protected final boolean isRobust(OopHandle handle) {
452 return RobustOopDeterminator.oopLooksValid(handle);
453 }
454
455 public Object readObjectArray(final ObjArray array) throws ClassNotFoundException {
456 Object result = getFromObjTable(array);
457 if (result == null) {
458 int length = (int) array.getLength();
459 ObjArrayKlass klass = (ObjArrayKlass) array.getKlass();
460 Klass bottomKls = klass.getBottomKlass();
461 Class bottomCls = null;
462 final int dimension = (int) klass.getDimension();
463 int[] dimArray = null;
464 if (bottomKls instanceof InstanceKlass) {
465 bottomCls = readClass((InstanceKlass) bottomKls);
466 dimArray = new int[dimension];
467 } else { // instanceof TypeArrayKlass
468 TypeArrayKlass botKls = (TypeArrayKlass) bottomKls;
469 dimArray = new int[dimension -1];
470 }
471 // initialize the length
472 dimArray[0] = length;
473 final Object[] arrayObj = (Object[]) java.lang.reflect.Array.newInstance(bottomCls, dimArray);
474 putIntoObjTable(array, arrayObj);
475 result = arrayObj;
476 array.iterate(new DefaultOopVisitor() {
477 public void doOop(OopField field, boolean isVMField) {
478 OopHandle handle = field.getValueAsOopHandle(getObj());
479 if (! isRobust(handle)) {
480 return;
481 }
482
483 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
484 try {
485 arrayObj[ifd.getIndex()] = readObject(field.getValue(getObj()));
486 } catch (Exception e) {
487 if (DEBUG) {
488 debugPrintln("Array element set failed for " + ifd);
489 debugPrintStackTrace(e);
490 }
491 }
492 }
493 }, false);
494 }
495 return result;
496 }
497
498 protected class FieldSetter extends DefaultOopVisitor {
499 protected Object obj;
500
501 public FieldSetter(Object obj) {
502 this.obj = obj;
503 }
504
505 private void printFieldSetError(java.lang.reflect.Field f, Exception ex) {
506 if (DEBUG) {
507 if (f != null) debugPrintln("Field set failed for " + f);
508 debugPrintStackTrace(ex);
509 }
510 }
511
512 // Callback methods for each field type in an object
513 public void doOop(OopField field, boolean isVMField) {
514 OopHandle handle = field.getValueAsOopHandle(getObj());
515 if (! isRobust(handle) ) {
516 return;
517 }
518
519 java.lang.reflect.Field f = null;
520 try {
521 f = readField(field);
522 if (Modifier.isFinal(f.getModifiers())) return;
523 f.setAccessible(true);
524 f.set(obj, readObject(field.getValue(getObj())));
525 } catch (Exception ex) {
526 printFieldSetError(f, ex);
527 }
528 }
529
530 public void doByte(ByteField field, boolean isVMField) {
531 java.lang.reflect.Field f = null;
532 try {
533 f = readField(field);
534 if (Modifier.isFinal(f.getModifiers())) return;
535 f.setAccessible(true);
536 f.setByte(obj, field.getValue(getObj()));
537 } catch (Exception ex) {
538 printFieldSetError(f, ex);
539 }
540 }
541
542 public void doChar(CharField field, boolean isVMField) {
543 java.lang.reflect.Field f = null;
544 try {
545 f = readField(field);
546 if (Modifier.isFinal(f.getModifiers())) return;
547 f.setAccessible(true);
548 f.setChar(obj, field.getValue(getObj()));
549 } catch (Exception ex) {
550 printFieldSetError(f, ex);
551 }
552 }
553
554 public void doBoolean(BooleanField field, boolean isVMField) {
555 java.lang.reflect.Field f = null;
556 try {
557 f = readField(field);
558 if (Modifier.isFinal(f.getModifiers())) return;
559 f.setAccessible(true);
560 f.setBoolean(obj, field.getValue(getObj()));
561 } catch (Exception ex) {
562 printFieldSetError(f, ex);
563 }
564 }
565
566 public void doShort(ShortField field, boolean isVMField) {
567 java.lang.reflect.Field f = null;
568 try {
569 f = readField(field);
570 if (Modifier.isFinal(f.getModifiers())) return;
571 f.setAccessible(true);
572 f.setShort(obj, field.getValue(getObj()));
573 } catch (Exception ex) {
574 printFieldSetError(f, ex);
575 }
576 }
577
578 public void doInt(IntField field, boolean isVMField) {
579 java.lang.reflect.Field f = null;
580 try {
581 f = readField(field);
582 if (Modifier.isFinal(f.getModifiers())) return;
583 f.setAccessible(true);
584 f.setInt(obj, field.getValue(getObj()));
585 } catch (Exception ex) {
586 printFieldSetError(f, ex);
587 }
588 }
589
590 public void doLong(LongField field, boolean isVMField) {
591 java.lang.reflect.Field f = null;
592 try {
593 f = readField(field);
594 if (Modifier.isFinal(f.getModifiers())) return;
595 f.setAccessible(true);
596 f.setLong(obj, field.getValue(getObj()));
597 } catch (Exception ex) {
598 printFieldSetError(f, ex);
599 }
600 }
601
602 public void doFloat(FloatField field, boolean isVMField) {
603 java.lang.reflect.Field f = null;
604 try {
605 f = readField(field);
606 if (Modifier.isFinal(f.getModifiers())) return;
607 f.setAccessible(true);
608 f.setFloat(obj, field.getValue(getObj()));
609 } catch (Exception ex) {
610 printFieldSetError(f, ex);
611 }
612 }
613
614 public void doDouble(DoubleField field, boolean isVMField) {
615 java.lang.reflect.Field f = null;
616 try {
617 f = readField(field);
618 if (Modifier.isFinal(f.getModifiers())) return;
619 f.setAccessible(true);
620 f.setDouble(obj, field.getValue(getObj()));
621 } catch (Exception ex) {
622 printFieldSetError(f, ex);
623 }
624 }
625
626 public void doCInt(CIntField field, boolean isVMField) {
627 throw new RuntimeException("should not reach here!");
628 }
629 }
630
631 public Class readClass(InstanceKlass kls) throws ClassNotFoundException {
632 Class cls = (Class) getFromObjTable(kls);
633 if (cls == null) {
634 cls = Class.forName(kls.getName().asString().replace('/', '.'), true, cl);
635 putIntoObjTable(kls, cls);
636 }
637 return cls;
638 }
639
640 public Object readMethodOrConstructor(sun.jvm.hotspot.oops.Method m)
641 throws NoSuchMethodException, ClassNotFoundException {
642 String name = m.getName().asString();
643 if (name.equals("<init>")) {
644 return readConstructor(m);
645 } else {
646 return readMethod(m);
647 }
648 }
649
650 public java.lang.reflect.Method readMethod(sun.jvm.hotspot.oops.Method m)
651 throws NoSuchMethodException, ClassNotFoundException {
652 java.lang.reflect.Method result = (java.lang.reflect.Method) getFromObjTable(m);
653 if (result == null) {
654 Class clz = readClass((InstanceKlass)m.getMethodHolder());
655 String name = m.getName().asString();
656 Class[] paramTypes = getParamTypes(m.getSignature());
657 result = clz.getMethod(name, paramTypes);
658 putIntoObjTable(m, result);
659 }
660 return result;
661 }
662
663 public java.lang.reflect.Constructor readConstructor(sun.jvm.hotspot.oops.Method m)
664 throws NoSuchMethodException, ClassNotFoundException {
665 java.lang.reflect.Constructor result = (java.lang.reflect.Constructor) getFromObjTable(m);
666 if (result == null) {
667 Class clz = readClass((InstanceKlass)m.getMethodHolder());
668 String name = m.getName().asString();
669 Class[] paramTypes = getParamTypes(m.getSignature());
670 result = clz.getDeclaredConstructor(paramTypes);
671 putIntoObjTable(m, result);
672 }
673 return result;
674 }
675
676 public java.lang.reflect.Field readField(sun.jvm.hotspot.oops.Field f)
677 throws NoSuchFieldException, ClassNotFoundException {
678 java.lang.reflect.Field result = (java.lang.reflect.Field) fieldMap.get(f);
679 if (result == null) {
680 FieldIdentifier fieldId = f.getID();
681 Class clz = readClass((InstanceKlass) f.getFieldHolder());
682 String name = fieldId.getName();
683 try {
684 result = clz.getField(name);
685 } catch (NoSuchFieldException nsfe) {
686 result = clz.getDeclaredField(name);
687 }
688 fieldMap.put(f, result);
689 }
690 return result;
691 }
692
693 protected final ClassLoader cl;
694 protected Map oopToObjMap; // Map<Oop, Object>
695 protected Map fieldMap; // Map<sun.jvm.hotspot.oops.Field, java.lang.reflect.Field>
696
697 protected void putIntoObjTable(Oop oop, Object obj) {
698 oopToObjMap.put(oop, obj);
699 }
700
701 protected Object getFromObjTable(Oop oop) {
702 return oopToObjMap.get(oop);
703 }
704
705 protected void putIntoObjTable(Metadata oop, Object obj) {
706 oopToObjMap.put(oop, obj);
707 }
708
709 protected Object getFromObjTable(Metadata oop) {
710 return oopToObjMap.get(oop);
711 }
712
713 protected class SignatureParser extends SignatureIterator {
714 protected Vector tmp = new Vector(); // Vector<Class>
715
716 public SignatureParser(Symbol s) {
717 super(s);
718 }
719
720 public void doBool () { tmp.add(Boolean.TYPE); }
721 public void doChar () { tmp.add(Character.TYPE); }
722 public void doFloat () { tmp.add(Float.TYPE); }
723 public void doDouble() { tmp.add(Double.TYPE); }
724 public void doByte () { tmp.add(Byte.TYPE); }
725 public void doShort () { tmp.add(Short.TYPE); }
726 public void doInt () { tmp.add(Integer.TYPE); }
727 public void doLong () { tmp.add(Long.TYPE); }
728 public void doVoid () {
729 if(isReturnType()) {
730 tmp.add(Void.TYPE);
731 } else {
732 throw new RuntimeException("should not reach here");
733 }
734 }
735
736 public void doObject(int begin, int end) {
737 tmp.add(getClass(begin, end));
738 }
739
740 public void doArray (int begin, int end) {
741 int inner = arrayInnerBegin(begin);
742 Class elemCls = null;
743 switch (_signature.getByteAt(inner)) {
744 case 'B': elemCls = Boolean.TYPE; break;
745 case 'C': elemCls = Character.TYPE; break;
746 case 'D': elemCls = Double.TYPE; break;
747 case 'F': elemCls = Float.TYPE; break;
748 case 'I': elemCls = Integer.TYPE; break;
749 case 'J': elemCls = Long.TYPE; break;
750 case 'S': elemCls = Short.TYPE; break;
751 case 'Z': elemCls = Boolean.TYPE; break;
752 case 'L': elemCls = getClass(inner + 1, end); break;
753 default: break;
754 }
755
756 int dimension = inner - begin;
757 // create 0 x 0 ... array and get class from that
758 int[] dimArray = new int[dimension];
759 tmp.add(java.lang.reflect.Array.newInstance(elemCls, dimArray).getClass());
760 }
761
762 protected Class getClass(int begin, int end) {
763 String className = getClassName(begin, end);
764 try {
765 return Class.forName(className, true, cl);
766 } catch (Exception e) {
767 if (DEBUG) {
768 debugPrintln("Can't load class " + className);
769 }
770 throw new RuntimeException(e);
771 }
772 }
773
774 protected String getClassName(int begin, int end) {
775 StringBuffer buf = new StringBuffer();
776 for (int i = begin; i < end; i++) {
777 char c = (char) (_signature.getByteAt(i) & 0xFF);
778 if (c == '/') {
779 buf.append('.');
780 } else {
781 buf.append(c);
782 }
783 }
784 return buf.toString();
785 }
786
787 protected int arrayInnerBegin(int begin) {
788 while (_signature.getByteAt(begin) == '[') {
789 ++begin;
790 }
791 return begin;
792 }
793
794 public int getNumParams() {
795 return tmp.size();
796 }
797
798 public Enumeration getParamTypes() {
799 return tmp.elements();
800 }
801 }
802
803 protected Class[] getParamTypes(Symbol signature) {
804 SignatureParser sp = new SignatureParser(signature);
805 sp.iterateParameters();
806 Class result[] = new Class[sp.getNumParams()];
807 Enumeration e = sp.getParamTypes();
808 int i = 0;
809 while (e.hasMoreElements()) {
810 result[i] = (Class) e.nextElement();
811 i++;
812 }
813 return result;
814 }
815 }