1 /*
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * - Neither the name of Oracle nor the names of its
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * This source code is provided to illustrate the usage of a given feature
34 * or technique and has been deliberately simplified. Additional steps
35 * required for a production-quality application, such as security checks,
36 * input validation and proper error handling, might not be present in
37 * this sample code.
38 */
39
40
41 /* Object references table (used in hprof_object.c). */
42
43 /*
44 * This table is used by the object table to store object reference
45 * and primitive data information obtained from iterations over the
46 * heap (see hprof_site.c).
47 *
48 * Most of these table entries have no Key, but the key is used to store
49 * the primitive array and primitive field jvalue. None of these entries
50 * are ever looked up, there will be no hash table, use of the
51 * LookupTable was just an easy way to handle a unbounded table of
52 * entries. The object table (see hprof_object.c) will completely
53 * free this reference table after each heap dump or after processing the
54 * references and primitive data.
55 *
56 * The hprof format required this accumulation of all heap iteration
57 * references and primitive data from objects in order to compose an
58 * hprof records for it.
59 *
60 * This file contains detailed understandings of how an hprof CLASS
61 * and INSTANCE dump is constructed, most of this is derived from the
62 * original hprof code, but some has been derived by reading the HAT
63 * code that accepts this format.
64 *
65 */
66
67 #include "hprof.h"
68
69 /* The flavor of data being saved in the RefInfo */
70 enum {
71 INFO_OBJECT_REF_DATA = 1,
72 INFO_PRIM_FIELD_DATA = 2,
73 INFO_PRIM_ARRAY_DATA = 3
74 };
75
76 /* Reference information, object reference or primitive data information */
77 typedef struct RefInfo {
78 ObjectIndex object_index; /* If an object reference, the referree index */
79 jint index; /* If array or field, array or field index */
80 jint length; /* If array the element count, if not -1 */
81 RefIndex next; /* The next table element */
82 unsigned flavor : 8; /* INFO_*, flavor of RefInfo */
83 unsigned refKind : 8; /* The kind of reference */
84 unsigned primType : 8; /* If primitive data involved, it's type */
85 } RefInfo;
86
87 /* Private internal functions. */
88
89 /* Get the RefInfo structure from an entry */
90 static RefInfo *
91 get_info(RefIndex index)
92 {
93 RefInfo *info;
94
95 info = (RefInfo*)table_get_info(gdata->reference_table, index);
96 return info;
97 }
98
99 /* Get a jvalue that was stored as the key. */
100 static jvalue
101 get_key_value(RefIndex index)
102 {
103 void *key;
104 int len;
105 jvalue value;
106 static jvalue empty_value;
107
108 key = NULL;
109 table_get_key(gdata->reference_table, index, &key, &len);
110 HPROF_ASSERT(key!=NULL);
111 HPROF_ASSERT(len==(int)sizeof(jvalue));
112 if ( key != NULL ) {
113 (void)memcpy(&value, key, (int)sizeof(jvalue));
114 } else {
115 value = empty_value;
116 }
117 return value;
118 }
119
120 /* Get size of a primitive type */
121 static jint
122 get_prim_size(jvmtiPrimitiveType primType)
123 {
124 jint size;
125
126 switch ( primType ) {
127 case JVMTI_PRIMITIVE_TYPE_BOOLEAN:
128 size = (jint)sizeof(jboolean);
129 break;
130 case JVMTI_PRIMITIVE_TYPE_BYTE:
131 size = (jint)sizeof(jbyte);
132 break;
133 case JVMTI_PRIMITIVE_TYPE_CHAR:
134 size = (jint)sizeof(jchar);
135 break;
136 case JVMTI_PRIMITIVE_TYPE_SHORT:
137 size = (jint)sizeof(jshort);
138 break;
139 case JVMTI_PRIMITIVE_TYPE_INT:
140 size = (jint)sizeof(jint);
141 break;
142 case JVMTI_PRIMITIVE_TYPE_FLOAT:
143 size = (jint)sizeof(jfloat);
144 break;
145 case JVMTI_PRIMITIVE_TYPE_LONG:
146 size = (jint)sizeof(jlong);
147 break;
148 case JVMTI_PRIMITIVE_TYPE_DOUBLE:
149 size = (jint)sizeof(jdouble);
150 break;
151 default:
152 HPROF_ASSERT(0);
153 size = 1;
154 break;
155 }
156 return size;
157 }
158
159 /* Get a void* elements array that was stored as the key. */
160 static void *
161 get_key_elements(RefIndex index, jvmtiPrimitiveType primType,
162 jint *nelements, jint *nbytes)
163 {
164 void *key;
165 jint byteLen;
166
167 HPROF_ASSERT(nelements!=NULL);
168 HPROF_ASSERT(nbytes!=NULL);
169
170 table_get_key(gdata->reference_table, index, &key, &byteLen);
171 HPROF_ASSERT(byteLen>=0);
172 HPROF_ASSERT(byteLen!=0?key!=NULL:key==NULL);
173 *nbytes = byteLen;
174 *nelements = byteLen / get_prim_size(primType);
175 return key;
176 }
177
178 /* Dump a RefInfo* structure */
179 static void
180 dump_ref_info(RefInfo *info)
181 {
182 debug_message("[%d]: flavor=%d"
183 ", refKind=%d"
184 ", primType=%d"
185 ", object_index=0x%x"
186 ", length=%d"
187 ", next=0x%x"
188 "\n",
189 info->index,
190 info->flavor,
191 info->refKind,
192 info->primType,
193 info->object_index,
194 info->length,
195 info->next);
196 }
197
198 /* Dump a RefIndex list */
199 static void
200 dump_ref_list(RefIndex list)
201 {
202 RefInfo *info;
203 RefIndex index;
204
205 debug_message("\nFOLLOW REFERENCES RETURNED:\n");
206 index = list;
207 while ( index != 0 ) {
208 info = get_info(index);
209 dump_ref_info(info);
210 index = info->next;
211 }
212 }
213
214 /* Dump information about a field and what ref data we had on it */
215 static void
216 dump_field(FieldInfo *fields, jvalue *fvalues, int n_fields,
217 jint index, jvalue value, jvmtiPrimitiveType primType)
218 {
219 ClassIndex cnum;
220 StringIndex name;
221 StringIndex sig;
222
223 cnum = fields[index].cnum;
224 name = fields[index].name_index;
225 sig = fields[index].sig_index;
226 debug_message("[%d] %s \"%s\" \"%s\"",
227 index,
228 cnum!=0?string_get(class_get_signature(cnum)):"?",
229 name!=0?string_get(name):"?",
230 sig!=0?string_get(sig):"?");
231 if ( fields[index].primType!=0 || fields[index].primType!=primType ) {
232 debug_message(" (primType=%d(%c)",
233 fields[index].primType,
234 primTypeToSigChar(fields[index].primType));
235 if ( primType != fields[index].primType ) {
236 debug_message(", got %d(%c)",
237 primType,
238 primTypeToSigChar(primType));
239 }
240 debug_message(")");
241 } else {
242 debug_message("(ty=OBJ)");
243 }
244 if ( value.j != (jlong)0 || fvalues[index].j != (jlong)0 ) {
245 debug_message(" val=[0x%08x,0x%08x] or [0x%08x,0x%08x]",
246 jlong_high(value.j), jlong_low(value.j),
247 jlong_high(fvalues[index].j), jlong_low(fvalues[index].j));
248 }
249 debug_message("\n");
250 }
251
252 /* Dump all the fields of interest */
253 static void
254 dump_fields(RefIndex list, FieldInfo *fields, jvalue *fvalues, int n_fields)
255 {
256 int i;
257
258 debug_message("\nHPROF LIST OF ALL FIELDS:\n");
259 for ( i = 0 ; i < n_fields ; i++ ) {
260 if ( fields[i].name_index != 0 ) {
261 dump_field(fields, fvalues, n_fields, i, fvalues[i], fields[i].primType);
262 }
263 }
264 dump_ref_list(list);
265 }
266
267 /* Verify field data */
268 static void
269 verify_field(RefIndex list, FieldInfo *fields, jvalue *fvalues, int n_fields,
270 jint index, jvalue value, jvmtiPrimitiveType primType)
271 {
272 HPROF_ASSERT(fvalues != NULL);
273 HPROF_ASSERT(n_fields > 0);
274 HPROF_ASSERT(index < n_fields);
275 HPROF_ASSERT(index >= 0 );
276 if ( primType!=fields[index].primType ) {
277 dump_fields(list, fields, fvalues, n_fields);
278 debug_message("\nPROBLEM WITH:\n");
279 dump_field(fields, fvalues, n_fields, index, value, primType);
280 debug_message("\n");
281 HPROF_ERROR(JNI_FALSE, "Trouble with fields and heap data");
282 }
283 if ( primType == JVMTI_PRIMITIVE_TYPE_BOOLEAN &&
284 ( value.b != 1 && value.b != 0 ) ) {
285 dump_fields(list, fields, fvalues, n_fields);
286 debug_message("\nPROBLEM WITH:\n");
287 dump_field(fields, fvalues, n_fields, index, value, primType);
288 debug_message("\n");
289 HPROF_ERROR(JNI_FALSE, "Trouble with fields and heap data");
290 }
291 }
292
293 /* Fill in a field value, making sure the index is safe */
294 static void
295 fill_in_field_value(RefIndex list, FieldInfo *fields, jvalue *fvalues,
296 int n_fields, jint index, jvalue value,
297 jvmtiPrimitiveType primType)
298 {
299 HPROF_ASSERT(fvalues != NULL);
300 HPROF_ASSERT(n_fields > 0);
301 HPROF_ASSERT(index < n_fields);
302 HPROF_ASSERT(index >= 0 );
303 HPROF_ASSERT(fvalues[index].j==(jlong)0);
304 verify_field(list, fields, fvalues, n_fields, index, value, primType);
305 if (index >= 0 && index < n_fields) {
306 fvalues[index] = value;
307 }
308 }
309
310 /* Walk all references for an ObjectIndex and construct the hprof CLASS dump. */
311 static void
312 dump_class_and_supers(JNIEnv *env, ObjectIndex object_index, RefIndex list)
313 {
314 SiteIndex site_index;
315 SerialNumber trace_serial_num;
316 RefIndex index;
317 ClassIndex super_cnum;
318 ObjectIndex super_index;
319 LoaderIndex loader_index;
320 ObjectIndex signers_index;
321 ObjectIndex domain_index;
322 FieldInfo *fields;
323 jvalue *fvalues;
324 jint n_fields;
325 jboolean skip_fields;
326 jint n_fields_set;
327 jlong size;
328 ClassIndex cnum;
329 char *sig;
330 ObjectKind kind;
331 TraceIndex trace_index;
332 Stack *cpool_values;
333 ConstantPoolValue *cpool;
334 jint cpool_count;
335
336 HPROF_ASSERT(object_index!=0);
337 kind = object_get_kind(object_index);
338 if ( kind != OBJECT_CLASS ) {
339 return;
340 }
341 site_index = object_get_site(object_index);
342 HPROF_ASSERT(site_index!=0);
343 cnum = site_get_class_index(site_index);
344 HPROF_ASSERT(cnum!=0);
345 if ( class_get_status(cnum) & CLASS_DUMPED ) {
346 return;
347 }
348 class_add_status(cnum, CLASS_DUMPED);
349 size = (jlong)object_get_size(object_index);
350
351 super_index = 0;
352 super_cnum = class_get_super(cnum);
353 if ( super_cnum != 0 ) {
354 super_index = class_get_object_index(super_cnum);
355 if ( super_index != 0 ) {
356 dump_class_and_supers(env, super_index,
357 object_get_references(super_index));
358 }
359 }
360
361 trace_index = site_get_trace_index(site_index);
362 HPROF_ASSERT(trace_index!=0);
363 trace_serial_num = trace_get_serial_number(trace_index);
364 sig = string_get(class_get_signature(cnum));
365 loader_index = class_get_loader(cnum);
366 signers_index = 0;
367 domain_index = 0;
368
369 /* Get field information */
370 n_fields = 0;
371 skip_fields = JNI_FALSE;
372 n_fields_set = 0;
373 fields = NULL;
374 fvalues = NULL;
375 if ( class_get_all_fields(env, cnum, &n_fields, &fields) == 1 ) {
376 /* Problems getting all the fields, can't trust field index values */
377 skip_fields = JNI_TRUE;
378 /* Class with no references at all? (ok to be unprepared if list==0?) */
379 if ( list != 0 ) {
380 /* It is assumed that the reason why we didn't get the fields
381 * was because the class is not prepared.
382 */
383 if ( gdata->debugflags & DEBUGFLAG_UNPREPARED_CLASSES ) {
384 dump_ref_list(list);
385 debug_message("Unprepared class with references: %s\n",
386 sig);
387 }
388 HPROF_ERROR(JNI_FALSE, "Trouble with unprepared classes");
389 }
390 /* Why would an unprepared class contain references? */
391 }
392 if ( n_fields > 0 ) {
393 fvalues = (jvalue*)HPROF_MALLOC(n_fields*(int)sizeof(jvalue));
394 (void)memset(fvalues, 0, n_fields*(int)sizeof(jvalue));
395 }
396
397 /* We use a Stack just because it will automatically expand as needed */
398 cpool_values = stack_init(16, 16, sizeof(ConstantPoolValue));
399 cpool = NULL;
400 cpool_count = 0;
401
402 index = list;
403 while ( index != 0 ) {
404 RefInfo *info;
405 jvalue ovalue;
406 static jvalue empty_value;
407
408 info = get_info(index);
409
410 switch ( info->flavor ) {
411 case INFO_OBJECT_REF_DATA:
412 switch ( info->refKind ) {
413 case JVMTI_HEAP_REFERENCE_FIELD:
414 case JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT:
415 /* Should never be seen on a class dump */
416 HPROF_ASSERT(0);
417 break;
418 case JVMTI_HEAP_REFERENCE_STATIC_FIELD:
419 if ( skip_fields == JNI_TRUE ) {
420 break;
421 }
422 ovalue = empty_value;
423 ovalue.i = info->object_index;
424 fill_in_field_value(list, fields, fvalues, n_fields,
425 info->index, ovalue, 0);
426 n_fields_set++;
427 HPROF_ASSERT(n_fields_set <= n_fields);
428 break;
429 case JVMTI_HEAP_REFERENCE_CONSTANT_POOL: {
430 ConstantPoolValue cpv;
431 ObjectIndex cp_object_index;
432 SiteIndex cp_site_index;
433 ClassIndex cp_cnum;
434
435 cp_object_index = info->object_index;
436 HPROF_ASSERT(cp_object_index!=0);
437 cp_site_index = object_get_site(cp_object_index);
438 HPROF_ASSERT(cp_site_index!=0);
439 cp_cnum = site_get_class_index(cp_site_index);
440 cpv.constant_pool_index = info->index;
441 cpv.sig_index = class_get_signature(cp_cnum);
442 cpv.value.i = cp_object_index;
443 stack_push(cpool_values, (void*)&cpv);
444 cpool_count++;
445 break;
446 }
447 case JVMTI_HEAP_REFERENCE_SIGNERS:
448 signers_index = info->object_index;
449 break;
450 case JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN:
451 domain_index = info->object_index;
452 break;
453 case JVMTI_HEAP_REFERENCE_CLASS_LOADER:
454 case JVMTI_HEAP_REFERENCE_INTERFACE:
455 default:
456 /* Ignore, not needed */
457 break;
458 }
459 break;
460 case INFO_PRIM_FIELD_DATA:
461 if ( skip_fields == JNI_TRUE ) {
462 break;
463 }
464 HPROF_ASSERT(info->primType!=0);
465 HPROF_ASSERT(info->length==-1);
466 HPROF_ASSERT(info->refKind==JVMTI_HEAP_REFERENCE_STATIC_FIELD);
467 ovalue = get_key_value(index);
468 fill_in_field_value(list, fields, fvalues, n_fields,
469 info->index, ovalue, info->primType);
470 n_fields_set++;
471 HPROF_ASSERT(n_fields_set <= n_fields);
472 break;
473 case INFO_PRIM_ARRAY_DATA:
474 default:
475 /* Should never see these */
476 HPROF_ASSERT(0);
477 break;
478 }
479
480 index = info->next;
481 }
482
483 /* Get constant pool data if we have any */
484 HPROF_ASSERT(cpool_count==stack_depth(cpool_values));
485 if ( cpool_count > 0 ) {
486 cpool = (ConstantPoolValue*)stack_element(cpool_values, 0);
487 }
488 io_heap_class_dump(cnum, sig, object_index, trace_serial_num,
489 super_index,
490 loader_object_index(env, loader_index),
491 signers_index, domain_index,
492 (jint)size, cpool_count, cpool, n_fields, fields, fvalues);
493
494 stack_term(cpool_values);
495 if ( fvalues != NULL ) {
496 HPROF_FREE(fvalues);
497 }
498 }
499
500 /* Walk all references for an ObjectIndex and construct the hprof INST dump. */
501 static void
502 dump_instance(JNIEnv *env, ObjectIndex object_index, RefIndex list)
503 {
504 jvmtiPrimitiveType primType;
505 SiteIndex site_index;
506 SerialNumber trace_serial_num;
507 RefIndex index;
508 ObjectIndex class_index;
509 jlong size;
510 ClassIndex cnum;
511 char *sig;
512 void *elements;
513 jint num_elements;
514 jint num_bytes;
515 ObjectIndex *values;
516 FieldInfo *fields;
517 jvalue *fvalues;
518 jint n_fields;
519 jboolean skip_fields;
520 jint n_fields_set;
521 ObjectKind kind;
522 TraceIndex trace_index;
523 jboolean is_array;
524 jboolean is_prim_array;
525
526 HPROF_ASSERT(object_index!=0);
527 kind = object_get_kind(object_index);
528 if ( kind == OBJECT_CLASS ) {
529 return;
530 }
531 site_index = object_get_site(object_index);
532 HPROF_ASSERT(site_index!=0);
533 cnum = site_get_class_index(site_index);
534 HPROF_ASSERT(cnum!=0);
535 size = (jlong)object_get_size(object_index);
536 trace_index = site_get_trace_index(site_index);
537 HPROF_ASSERT(trace_index!=0);
538 trace_serial_num = trace_get_serial_number(trace_index);
539 sig = string_get(class_get_signature(cnum));
540 class_index = class_get_object_index(cnum);
541
542 values = NULL;
543 elements = NULL;
544 num_elements = 0;
545 num_bytes = 0;
546
547 n_fields = 0;
548 skip_fields = JNI_FALSE;
549 n_fields_set = 0;
550 fields = NULL;
551 fvalues = NULL;
552
553 index = list;
554
555 is_array = JNI_FALSE;
556 is_prim_array = JNI_FALSE;
557
558 if ( sig[0] != JVM_SIGNATURE_ARRAY ) {
559 if ( class_get_all_fields(env, cnum, &n_fields, &fields) == 1 ) {
560 /* Trouble getting all the fields, can't trust field index values */
561 skip_fields = JNI_TRUE;
562 /* It is assumed that the reason why we didn't get the fields
563 * was because the class is not prepared.
564 */
565 if ( gdata->debugflags & DEBUGFLAG_UNPREPARED_CLASSES ) {
566 if ( list != 0 ) {
567 dump_ref_list(list);
568 debug_message("Instance of unprepared class with refs: %s\n",
569 sig);
570 } else {
571 debug_message("Instance of unprepared class without refs: %s\n",
572 sig);
573 }
574 HPROF_ERROR(JNI_FALSE, "Big Trouble with unprepared class instances");
575 }
576 }
577 if ( n_fields > 0 ) {
578 fvalues = (jvalue*)HPROF_MALLOC(n_fields*(int)sizeof(jvalue));
579 (void)memset(fvalues, 0, n_fields*(int)sizeof(jvalue));
580 }
581 } else {
582 is_array = JNI_TRUE;
583 if ( sig[0] != 0 && sigToPrimSize(sig+1) != 0 ) {
584 is_prim_array = JNI_TRUE;
585 }
586 }
587
588 while ( index != 0 ) {
589 RefInfo *info;
590 jvalue ovalue;
591 static jvalue empty_value;
592
593 info = get_info(index);
594
595 /* Process reference objects, many not used right now. */
596 switch ( info->flavor ) {
597 case INFO_OBJECT_REF_DATA:
598 switch ( info->refKind ) {
599 case JVMTI_HEAP_REFERENCE_SIGNERS:
600 case JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN:
601 case JVMTI_HEAP_REFERENCE_CLASS_LOADER:
602 case JVMTI_HEAP_REFERENCE_INTERFACE:
603 case JVMTI_HEAP_REFERENCE_STATIC_FIELD:
604 case JVMTI_HEAP_REFERENCE_CONSTANT_POOL:
605 /* Should never be seen on an instance dump */
606 HPROF_ASSERT(0);
607 break;
608 case JVMTI_HEAP_REFERENCE_FIELD:
609 if ( skip_fields == JNI_TRUE ) {
610 break;
611 }
612 HPROF_ASSERT(is_array!=JNI_TRUE);
613 ovalue = empty_value;
614 ovalue.i = info->object_index;
615 fill_in_field_value(list, fields, fvalues, n_fields,
616 info->index, ovalue, 0);
617 n_fields_set++;
618 HPROF_ASSERT(n_fields_set <= n_fields);
619 break;
620 case JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT:
621 /* We get each object element one at a time. */
622 HPROF_ASSERT(is_array==JNI_TRUE);
623 HPROF_ASSERT(is_prim_array!=JNI_TRUE);
624 if ( num_elements <= info->index ) {
625 int nbytes;
626
627 if ( values == NULL ) {
628 num_elements = info->index + 1;
629 nbytes = num_elements*(int)sizeof(ObjectIndex);
630 values = (ObjectIndex*)HPROF_MALLOC(nbytes);
631 (void)memset(values, 0, nbytes);
632 } else {
633 void *new_values;
634 int new_size;
635 int obytes;
636
637 obytes = num_elements*(int)sizeof(ObjectIndex);
638 new_size = info->index + 1;
639 nbytes = new_size*(int)sizeof(ObjectIndex);
640 new_values = (void*)HPROF_MALLOC(nbytes);
641 (void)memcpy(new_values, values, obytes);
642 (void)memset(((char*)new_values)+obytes, 0,
643 nbytes-obytes);
644 HPROF_FREE(values);
645 num_elements = new_size;
646 values = new_values;
647 }
648 }
649 HPROF_ASSERT(values[info->index]==0);
650 values[info->index] = info->object_index;
651 break;
652 default:
653 /* Ignore, not needed */
654 break;
655 }
656 break;
657 case INFO_PRIM_FIELD_DATA:
658 if ( skip_fields == JNI_TRUE ) {
659 break;
660 }
661 HPROF_ASSERT(info->primType!=0);
662 HPROF_ASSERT(info->length==-1);
663 HPROF_ASSERT(info->refKind==JVMTI_HEAP_REFERENCE_FIELD);
664 HPROF_ASSERT(is_array!=JNI_TRUE);
665 ovalue = get_key_value(index);
666 fill_in_field_value(list, fields, fvalues, n_fields,
667 info->index, ovalue, info->primType);
668 n_fields_set++;
669 HPROF_ASSERT(n_fields_set <= n_fields);
670 break;
671 case INFO_PRIM_ARRAY_DATA:
672 /* Should only be one, and it's handled below */
673 HPROF_ASSERT(info->refKind==0);
674 /* We assert that nothing else was saved with this array */
675 HPROF_ASSERT(index==list&&info->next==0);
676 HPROF_ASSERT(is_array==JNI_TRUE);
677 HPROF_ASSERT(is_prim_array==JNI_TRUE);
678 primType = info->primType;
679 elements = get_key_elements(index, primType,
680 &num_elements, &num_bytes);
681 HPROF_ASSERT(info->length==num_elements);
682 size = num_bytes;
683 break;
684 default:
685 HPROF_ASSERT(0);
686 break;
687 }
688 index = info->next;
689 }
690
691 if ( is_array == JNI_TRUE ) {
692 if ( is_prim_array == JNI_TRUE ) {
693 HPROF_ASSERT(values==NULL);
694 io_heap_prim_array(object_index, trace_serial_num,
695 (jint)size, num_elements, sig, elements);
696 } else {
697 HPROF_ASSERT(elements==NULL);
698 io_heap_object_array(object_index, trace_serial_num,
699 (jint)size, num_elements, sig, values, class_index);
700 }
701 } else {
702 io_heap_instance_dump(cnum, object_index, trace_serial_num,
703 class_index, (jint)size, sig, fields, fvalues, n_fields);
704 }
705 if ( values != NULL ) {
706 HPROF_FREE(values);
707 }
708 if ( fvalues != NULL ) {
709 HPROF_FREE(fvalues);
710 }
711 if ( elements != NULL ) {
712 /* Do NOT free elements, it's a key in the table, leave it be */
713 }
714 }
715
716 /* External interfaces. */
717
718 void
719 reference_init(void)
720 {
721 HPROF_ASSERT(gdata->reference_table==NULL);
722 gdata->reference_table = table_initialize("Ref", 2048, 4096, 0,
723 (int)sizeof(RefInfo));
724 }
725
726 /* Save away a reference to an object */
727 RefIndex
728 reference_obj(RefIndex next, jvmtiHeapReferenceKind refKind,
729 ObjectIndex object_index, jint index, jint length)
730 {
731 static RefInfo empty_info;
732 RefIndex entry;
733 RefInfo info;
734
735 info = empty_info;
736 info.flavor = INFO_OBJECT_REF_DATA;
737 info.refKind = refKind;
738 info.object_index = object_index;
739 info.index = index;
740 info.length = length;
741 info.next = next;
742 entry = table_create_entry(gdata->reference_table, NULL, 0, (void*)&info);
743 return entry;
744 }
745
746 /* Save away some primitive field data */
747 RefIndex
748 reference_prim_field(RefIndex next, jvmtiHeapReferenceKind refKind,
749 jvmtiPrimitiveType primType, jvalue field_value, jint field_index)
750 {
751 static RefInfo empty_info;
752 RefIndex entry;
753 RefInfo info;
754
755 HPROF_ASSERT(primType==JVMTI_PRIMITIVE_TYPE_BOOLEAN?(field_value.b==1||field_value.b==0):1);
756
757 info = empty_info;
758 info.flavor = INFO_PRIM_FIELD_DATA;
759 info.refKind = refKind;
760 info.primType = primType;
761 info.index = field_index;
762 info.length = -1;
763 info.next = next;
764 entry = table_create_entry(gdata->reference_table,
765 (void*)&field_value, (int)sizeof(jvalue), (void*)&info);
766 return entry;
767 }
768
769 /* Save away some primitive array data */
770 RefIndex
771 reference_prim_array(RefIndex next, jvmtiPrimitiveType primType,
772 const void *elements, jint elementCount)
773 {
774 static RefInfo empty_info;
775 RefIndex entry;
776 RefInfo info;
777
778 HPROF_ASSERT(next == 0);
779 HPROF_ASSERT(elementCount >= 0);
780 HPROF_ASSERT(elements != NULL);
781
782 info = empty_info;
783 info.flavor = INFO_PRIM_ARRAY_DATA;
784 info.refKind = 0;
785 info.primType = primType;
786 info.index = 0;
787 info.length = elementCount;
788 info.next = next;
789 entry = table_create_entry(gdata->reference_table, (void*)elements,
790 elementCount * get_prim_size(primType), (void*)&info);
791 return entry;
792 }
793
794 void
795 reference_cleanup(void)
796 {
797 if ( gdata->reference_table == NULL ) {
798 return;
799 }
800 table_cleanup(gdata->reference_table, NULL, NULL);
801 gdata->reference_table = NULL;
802 }
803
804 void
805 reference_dump_instance(JNIEnv *env, ObjectIndex object_index, RefIndex list)
806 {
807 dump_instance(env, object_index, list);
808 }
809
810 void
811 reference_dump_class(JNIEnv *env, ObjectIndex object_index, RefIndex list)
812 {
813 dump_class_and_supers(env, object_index, list);
814 }