48 public static final long SMALL_ID_MASK = 0x0FFFFFFFFL;
49 public static final JavaThing[] EMPTY_JAVATHING_ARRAY = new JavaThing[0];
50
51 private static final JavaField[] EMPTY_FIELD_ARRAY = new JavaField[0];
52 private static final JavaStatic[] EMPTY_STATIC_ARRAY = new JavaStatic[0];
53
54 // all heap objects
55 private Hashtable<Number, JavaHeapObject> heapObjects =
56 new Hashtable<Number, JavaHeapObject>();
57
58 private Hashtable<Number, JavaClass> fakeClasses =
59 new Hashtable<Number, JavaClass>();
60
61 // all Roots in this Snapshot
62 private Vector<Root> roots = new Vector<Root>();
63
64 // name-to-class map
65 private Map<String, JavaClass> classes =
66 new TreeMap<String, JavaClass>();
67
68 // new objects relative to a baseline - lazily initialized
69 private volatile Map<JavaHeapObject, Boolean> newObjects;
70
71 // allocation site traces for all objects - lazily initialized
72 private volatile Map<JavaHeapObject, StackTrace> siteTraces;
73
74 // object-to-Root map for all objects
75 private Map<JavaHeapObject, Root> rootsMap =
76 new HashMap<JavaHeapObject, Root>();
77
78 // soft cache of finalizeable objects - lazily initialized
79 private SoftReference<Vector<?>> finalizablesCache;
80
81 // threads
82 private ArrayList<ThreadObject> threads = new ArrayList<>();
83
84 // represents null reference
85 private JavaThing nullThing;
86
87 // java.lang.ref.Reference class
188 int numInts = instSize / 4;
189 int numBytes = instSize % 4;
190 JavaField[] fields = new JavaField[numInts + numBytes];
191 int i;
192 for (i = 0; i < numInts; i++) {
193 fields[i] = new JavaField("unknown-field-" + i, "I");
194 }
195 for (i = 0; i < numBytes; i++) {
196 fields[i + numInts] = new JavaField("unknown-field-" +
197 i + numInts, "B");
198 }
199
200 // Create fake instance class
201 JavaClass c = new JavaClass(name, 0, 0, 0, 0, fields,
202 EMPTY_STATIC_ARRAY, instSize);
203 // Add the class
204 addFakeClass(makeId(classID), c);
205 return c;
206 }
207
208
209 /**
210 * @return true iff it's possible that some JavaThing instances might
211 * isNew set
212 *
213 * @see JavaThing.isNew()
214 */
215 public boolean getHasNewSet() {
216 return hasNewSet;
217 }
218
219 //
220 // Used in the body of resolve()
221 //
222 private static class MyVisitor extends AbstractJavaHeapObjectVisitor {
223 JavaHeapObject t;
224 public void visit(JavaHeapObject other) {
225 other.addReferenceFrom(t);
226 }
227 }
|
48 public static final long SMALL_ID_MASK = 0x0FFFFFFFFL;
49 public static final JavaThing[] EMPTY_JAVATHING_ARRAY = new JavaThing[0];
50
51 private static final JavaField[] EMPTY_FIELD_ARRAY = new JavaField[0];
52 private static final JavaStatic[] EMPTY_STATIC_ARRAY = new JavaStatic[0];
53
54 // all heap objects
55 private Hashtable<Number, JavaHeapObject> heapObjects =
56 new Hashtable<Number, JavaHeapObject>();
57
58 private Hashtable<Number, JavaClass> fakeClasses =
59 new Hashtable<Number, JavaClass>();
60
61 // all Roots in this Snapshot
62 private Vector<Root> roots = new Vector<Root>();
63
64 // name-to-class map
65 private Map<String, JavaClass> classes =
66 new TreeMap<String, JavaClass>();
67
68 private Map<Number, Number> flatArrays = new HashMap<>();
69
70 private Map<Number, ClassInlinedFields[]> inlinedFields = new HashMap<>();
71
72 // new objects relative to a baseline - lazily initialized
73 private volatile Map<JavaHeapObject, Boolean> newObjects;
74
75 // allocation site traces for all objects - lazily initialized
76 private volatile Map<JavaHeapObject, StackTrace> siteTraces;
77
78 // object-to-Root map for all objects
79 private Map<JavaHeapObject, Root> rootsMap =
80 new HashMap<JavaHeapObject, Root>();
81
82 // soft cache of finalizeable objects - lazily initialized
83 private SoftReference<Vector<?>> finalizablesCache;
84
85 // threads
86 private ArrayList<ThreadObject> threads = new ArrayList<>();
87
88 // represents null reference
89 private JavaThing nullThing;
90
91 // java.lang.ref.Reference class
192 int numInts = instSize / 4;
193 int numBytes = instSize % 4;
194 JavaField[] fields = new JavaField[numInts + numBytes];
195 int i;
196 for (i = 0; i < numInts; i++) {
197 fields[i] = new JavaField("unknown-field-" + i, "I");
198 }
199 for (i = 0; i < numBytes; i++) {
200 fields[i + numInts] = new JavaField("unknown-field-" +
201 i + numInts, "B");
202 }
203
204 // Create fake instance class
205 JavaClass c = new JavaClass(name, 0, 0, 0, 0, fields,
206 EMPTY_STATIC_ARRAY, instSize);
207 // Add the class
208 addFakeClass(makeId(classID), c);
209 return c;
210 }
211
212 public void addFlatArray(long objID, long elementClassID) {
213 flatArrays.put(makeId(objID), makeId(elementClassID));
214 }
215
216 /**
217 * @return null if the array is not flat array
218 */
219 Number findFlatArrayElementType(long arrayObjectID) {
220 return flatArrays.get(makeId(arrayObjectID));
221 }
222
223 public static class ClassInlinedFields {
224 final int fieldIndex;
225 final int synthFieldCount;
226 final String fieldName;
227 final long fieldClassID;
228
229 public ClassInlinedFields(int fieldIndex, int synthFieldCount, String fieldName, long fieldClassID) {
230 this.fieldIndex = fieldIndex;
231 this.synthFieldCount = synthFieldCount;
232 this.fieldName = fieldName;
233 this.fieldClassID = fieldClassID;
234 }
235 }
236
237 public void addClassInlinedFields(long classID, ClassInlinedFields[] fields) {
238 inlinedFields.put(makeId(classID), fields);
239 }
240
241 /**
242 * @return null if the class has no inlined fields
243 */
244 ClassInlinedFields[] findClassInlinedFields(long classID) {
245 return inlinedFields.get(makeId(classID));
246 }
247
248 /**
249 * @return true iff it's possible that some JavaThing instances might
250 * isNew set
251 *
252 * @see JavaThing.isNew()
253 */
254 public boolean getHasNewSet() {
255 return hasNewSet;
256 }
257
258 //
259 // Used in the body of resolve()
260 //
261 private static class MyVisitor extends AbstractJavaHeapObjectVisitor {
262 JavaHeapObject t;
263 public void visit(JavaHeapObject other) {
264 other.addReferenceFrom(t);
265 }
266 }
|