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