hotspot/src/share/vm/services/heapDumper.cpp
author drchase
Fri, 09 May 2014 16:50:54 -0400
changeset 24424 2658d7834c6e
parent 22895 52fbddf39901
child 25468 5331df506290
permissions -rw-r--r--
8037816: Fix for 8036122 breaks build with Xcode5/clang Summary: Repaired or selectively disabled offending formats; future-proofed with additional checking Reviewed-by: kvn, jrose, stefank
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22895
diff changeset
     2
 * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4571
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    26
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    28
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    29
#include "gc_implementation/shared/vmGCOperations.hpp"
11000
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
    30
#include "memory/gcLocker.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    31
#include "memory/genCollectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    32
#include "memory/universe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    33
#include "oops/objArrayKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    34
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    35
#include "runtime/jniHandles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    36
#include "runtime/reflectionUtils.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    37
#include "runtime/vframe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    38
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    39
#include "runtime/vm_operations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    40
#include "services/heapDumper.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    41
#include "services/threadService.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    42
#include "utilities/ostream.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14488
diff changeset
    43
#include "utilities/macros.hpp"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14488
diff changeset
    44
#if INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6445
diff changeset
    45
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14488
diff changeset
    46
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
 * HPROF binary format - description copied from:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
 *   src/share/demo/jvmti/hprof/hprof_io.c
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
 *  header    "JAVA PROFILE 1.0.1" or "JAVA PROFILE 1.0.2"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
 *            (0-terminated)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
 *  u4        size of identifiers. Identifiers are used to represent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
 *            UTF8 strings, objects, stack traces, etc. They usually
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 *            have the same size as host pointers. For example, on
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 *            Solaris and Win32, the size is 4.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
 * u4         high word
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
 * u4         low word    number of milliseconds since 0:00 GMT, 1/1/70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
 * [record]*  a sequence of records.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
 * Record format:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
 * u1         a TAG denoting the type of the record
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
 * u4         number of *microseconds* since the time stamp in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 *            header. (wraps around in a little more than an hour)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
 * u4         number of bytes *remaining* in the record. Note that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
 *            this number excludes the tag and the length field itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
 * [u1]*      BODY of the record (a sequence of bytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
 * The following TAGs are supported:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
 * TAG           BODY       notes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
 *----------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
 * HPROF_UTF8               a UTF8-encoded name
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
 *               id         name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
 *               [u1]*      UTF8 characters (no trailing zero)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
 * HPROF_LOAD_CLASS         a newly loaded class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
 *                u4        class serial number (> 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
 *                id        class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
 *                u4        stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 *                id        class name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
 * HPROF_UNLOAD_CLASS       an unloading class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
 *                u4        class serial_number
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
 * HPROF_FRAME              a Java stack frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
 *                id        stack frame ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
 *                id        method name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
 *                id        method signature ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
 *                id        source file name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
 *                u4        class serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
 *                i4        line number. >0: normal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
 *                                       -1: unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
 *                                       -2: compiled method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
 *                                       -3: native method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
 * HPROF_TRACE              a Java stack trace
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
 *               u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
 *               u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
 *               u4         number of frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
 *               [id]*      stack frame IDs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
 * HPROF_ALLOC_SITES        a set of heap allocation sites, obtained after GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
 *               u2         flags 0x0001: incremental vs. complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
 *                                0x0002: sorted by allocation vs. live
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
 *                                0x0004: whether to force a GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
 *               u4         cutoff ratio
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
 *               u4         total live bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 *               u4         total live instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
 *               u8         total bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
 *               u8         total instances allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
 *               u4         number of sites that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
 *               [u1        is_array: 0:  normal object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
 *                                    2:  object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
 *                                    4:  boolean array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
 *                                    5:  char array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
 *                                    6:  float array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
 *                                    7:  double array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
 *                                    8:  byte array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
 *                                    9:  short array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
 *                                    10: int array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
 *                                    11: long array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
 *                u4        class serial number (may be zero during startup)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
 *                u4        stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
 *                u4        number of bytes alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
 *                u4        number of instances alive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
 *                u4        number of bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
 *                u4]*      number of instance allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
 * HPROF_START_THREAD       a newly started thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
 *               u4         thread serial number (> 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
 *               id         thread object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
 *               u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
 *               id         thread name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
 *               id         thread group name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
 *               id         thread group parent name ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
 * HPROF_END_THREAD         a terminating thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
 *               u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
 * HPROF_HEAP_SUMMARY       heap summary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
 *               u4         total live bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
 *               u4         total live instances
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
 *               u8         total bytes allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
 *               u8         total instances allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
 * HPROF_HEAP_DUMP          denote a heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
 *               [heap dump sub-records]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
 *                          There are four kinds of heap dump sub-records:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
 *               u1         sub-record type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
 *               HPROF_GC_ROOT_UNKNOWN         unknown root
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
 *               HPROF_GC_ROOT_THREAD_OBJ      thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
 *                          id         thread object ID  (may be 0 for a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
 *                                     thread newly attached through JNI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
 *                          u4         thread sequence number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
 *                          u4         stack trace sequence number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
 *               HPROF_GC_ROOT_JNI_GLOBAL      JNI global ref root
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
 *                          id         JNI global ref ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
 *               HPROF_GC_ROOT_JNI_LOCAL       JNI local ref
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
 *                          u4         frame # in stack trace (-1 for empty)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
 *               HPROF_GC_ROOT_JAVA_FRAME      Java stack frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
 *                          u4         frame # in stack trace (-1 for empty)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
 *               HPROF_GC_ROOT_NATIVE_STACK    Native stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
 *               HPROF_GC_ROOT_STICKY_CLASS    System class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
 *               HPROF_GC_ROOT_THREAD_BLOCK    Reference from thread block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
 *                          u4         thread serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
 *               HPROF_GC_ROOT_MONITOR_USED    Busy monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
 *               HPROF_GC_CLASS_DUMP           dump of a class object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
 *                          id         class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
 *                          id         super class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
 *                          id         class loader object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
 *                          id         signers object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
 *                          id         protection domain object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
 *                          id         reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
 *                          id         reserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
 *                          u4         instance size (in bytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
 *                          u2         size of constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
 *                          [u2,       constant pool index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
 *                           ty,       type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
 *                                     2:  object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
 *                                     4:  boolean
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
 *                                     5:  char
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
 *                                     6:  float
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
 *                                     7:  double
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
 *                                     8:  byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
 *                                     9:  short
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
 *                                     10: int
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
 *                                     11: long
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
 *                           vl]*      and value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
 *                          u2         number of static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
 *                          [id,       static field name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
 *                           ty,       type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
 *                           vl]*      and value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
 *                          u2         number of inst. fields (not inc. super)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
 *                          [id,       instance field name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
 *                           ty]*      type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
 *               HPROF_GC_INSTANCE_DUMP        dump of a normal object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
 *                          id         object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
 *                          id         class object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
 *                          u4         number of bytes that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
 *                          [vl]*      instance field values (class, followed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
 *                                     by super, super's super ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
 *               HPROF_GC_OBJ_ARRAY_DUMP       dump of an object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
 *                          id         array object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
 *                          u4         number of elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
 *                          id         array class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
 *                          [id]*      elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
 *               HPROF_GC_PRIM_ARRAY_DUMP      dump of a primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
 *                          id         array object ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
 *                          u4         stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
 *                          u4         number of elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
 *                          u1         element type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
 *                                     4:  boolean array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
 *                                     5:  char array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
 *                                     6:  float array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
 *                                     7:  double array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
 *                                     8:  byte array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
 *                                     9:  short array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
 *                                     10: int array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
 *                                     11: long array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
 *                          [u1]*      elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
 * HPROF_CPU_SAMPLES        a set of sample traces of running threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
 *                u4        total number of samples
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
 *                u4        # of traces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
 *               [u4        # of samples
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
 *                u4]*      stack trace serial number
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
 * HPROF_CONTROL_SETTINGS   the settings of on/off switches
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
 *                u4        0x00000001: alloc traces on/off
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
 *                          0x00000002: cpu sampling on/off
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
 *                u2        stack trace depth
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
 * When the header is "JAVA PROFILE 1.0.2" a heap dump can optionally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
 * be generated as a sequence of heap dump segments. This sequence is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
 * terminated by an end record. The additional tags allowed by format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
 * "JAVA PROFILE 1.0.2" are:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
 * HPROF_HEAP_DUMP_SEGMENT  denote a heap dump segment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
 *               [heap dump sub-records]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
 *               The same sub-record types allowed by HPROF_HEAP_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 * HPROF_HEAP_DUMP_END      denotes the end of a heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
// HPROF tags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
typedef enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // top-level records
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  HPROF_UTF8                    = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  HPROF_LOAD_CLASS              = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  HPROF_UNLOAD_CLASS            = 0x03,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  HPROF_FRAME                   = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  HPROF_TRACE                   = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  HPROF_ALLOC_SITES             = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  HPROF_HEAP_SUMMARY            = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  HPROF_START_THREAD            = 0x0A,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  HPROF_END_THREAD              = 0x0B,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  HPROF_HEAP_DUMP               = 0x0C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  HPROF_CPU_SAMPLES             = 0x0D,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  HPROF_CONTROL_SETTINGS        = 0x0E,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // 1.0.2 record types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  HPROF_HEAP_DUMP_SEGMENT       = 0x1C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  HPROF_HEAP_DUMP_END           = 0x2C,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // field types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  HPROF_ARRAY_OBJECT            = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  HPROF_NORMAL_OBJECT           = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  HPROF_BOOLEAN                 = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  HPROF_CHAR                    = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  HPROF_FLOAT                   = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  HPROF_DOUBLE                  = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  HPROF_BYTE                    = 0x08,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  HPROF_SHORT                   = 0x09,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  HPROF_INT                     = 0x0A,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  HPROF_LONG                    = 0x0B,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // data-dump sub-records
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  HPROF_GC_ROOT_UNKNOWN         = 0xFF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  HPROF_GC_ROOT_JNI_GLOBAL      = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  HPROF_GC_ROOT_JNI_LOCAL       = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  HPROF_GC_ROOT_JAVA_FRAME      = 0x03,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  HPROF_GC_ROOT_NATIVE_STACK    = 0x04,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  HPROF_GC_ROOT_STICKY_CLASS    = 0x05,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  HPROF_GC_ROOT_THREAD_BLOCK    = 0x06,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  HPROF_GC_ROOT_MONITOR_USED    = 0x07,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  HPROF_GC_ROOT_THREAD_OBJ      = 0x08,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  HPROF_GC_CLASS_DUMP           = 0x20,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  HPROF_GC_INSTANCE_DUMP        = 0x21,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  HPROF_GC_OBJ_ARRAY_DUMP       = 0x22,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  HPROF_GC_PRIM_ARRAY_DUMP      = 0x23
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
} hprofTag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
// Default stack trace ID (used for dummy HPROF_TRACE record)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
enum {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   366
  STACK_TRACE_ID = 1,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   367
  INITIAL_CLASS_COUNT = 200
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
// Supports I/O operations on a dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
class DumpWriter : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    io_buffer_size  = 8*M
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  int _fd;              // file descriptor (-1 if dump file not open)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  jlong _bytes_written; // number of byte written to dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  char* _buffer;    // internal buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  int _size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  int _pos;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  char* _error;   // error message when I/O fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  void set_file_descriptor(int fd)              { _fd = fd; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  int file_descriptor() const                   { return _fd; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  char* buffer() const                          { return _buffer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  int buffer_size() const                       { return _size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  int position() const                          { return _pos; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  void set_position(int pos)                    { _pos = pos; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  void set_error(const char* error)             { _error = (char*)os::strdup(error); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  // all I/O go through this function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  void write_internal(void* s, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  DumpWriter(const char* path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  ~DumpWriter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  void close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  bool is_open() const                  { return file_descriptor() >= 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  void flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  // total number of bytes written to the disk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  jlong bytes_written() const           { return _bytes_written; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  // adjust the number of bytes written to disk (used to keep the count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  // of the number of bytes written in case of rewrites)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  void adjust_bytes_written(jlong n)     { _bytes_written += n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  // number of (buffered) bytes as yet unwritten to the dump file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  jlong bytes_unwritten() const          { return (jlong)position(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  char* error() const                   { return _error; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  jlong current_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  void seek_to_offset(jlong pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  // writer functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  void write_raw(void* s, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  void write_u1(u1 x)                   { write_raw((void*)&x, 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  void write_u2(u2 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  void write_u4(u4 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  void write_u8(u8 x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  void write_objectID(oop o);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   430
  void write_symbolID(Symbol* o);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  void write_classID(Klass* k);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   432
  void write_id(u4 x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
DumpWriter::DumpWriter(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // try to allocate an I/O buffer of io_buffer_size. If there isn't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // sufficient memory then reduce size until we can allocate something.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  _size = io_buffer_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  do {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
   440
    _buffer = (char*)os::malloc(_size, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
    if (_buffer == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
      _size = _size >> 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  } while (_buffer == NULL && _size > 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  assert((_size > 0 && _buffer != NULL) || (_size == 0 && _buffer == NULL), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  _pos = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  _error = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  _bytes_written = 0L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  _fd = os::create_binary_file(path, false);    // don't replace existing file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // if the open failed we record the error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  if (_fd < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    _error = (char*)os::strdup(strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
DumpWriter::~DumpWriter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  // flush and close dump file
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
   459
  if (is_open()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  if (_buffer != NULL) os::free(_buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  if (_error != NULL) os::free(_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
// closes dump file (if open)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
void DumpWriter::close() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // flush and close dump file
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
   469
  if (is_open()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    ::close(file_descriptor());
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
   472
    set_file_descriptor(-1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
// write directly to the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
void DumpWriter::write_internal(void* s, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    int n = ::write(file_descriptor(), s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    if (n > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
      _bytes_written += n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    if (n != len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
      if (n < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
        set_error(strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
        set_error("file size limit");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
      ::close(file_descriptor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      set_file_descriptor(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
// write raw bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
void DumpWriter::write_raw(void* s, int len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    // flush buffer to make toom
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
    if ((position()+ len) >= buffer_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
      flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    // buffer not available or too big to buffer it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    if ((buffer() == NULL) || (len >= buffer_size())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
      write_internal(s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
      // Should optimize this for u1/u2/u4/u8 sizes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
      memcpy(buffer() + position(), s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
      set_position(position() + len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
// flush any buffered bytes to the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
void DumpWriter::flush() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  if (is_open() && position() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    write_internal(buffer(), position());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    set_position(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
jlong DumpWriter::current_offset() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    // the offset is the file offset plus whatever we have buffered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    jlong offset = os::current_file_offset(file_descriptor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    assert(offset >= 0, "lseek failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    return offset + (jlong)position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    return (jlong)-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
void DumpWriter::seek_to_offset(jlong off) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  assert(off >= 0, "bad offset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  // need to flush before seeking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // may be closed due to I/O error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  if (is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
    jlong n = os::seek_to_file_offset(file_descriptor(), off);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    assert(n >= 0, "lseek failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
void DumpWriter::write_u2(u2 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  u2 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  Bytes::put_Java_u2((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  write_raw((void*)&v, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
void DumpWriter::write_u4(u4 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  u4 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  Bytes::put_Java_u4((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  write_raw((void*)&v, 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
void DumpWriter::write_u8(u8 x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  u8 v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  Bytes::put_Java_u8((address)&v, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  write_raw((void*)&v, 8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
void DumpWriter::write_objectID(oop o) {
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 15483
diff changeset
   566
  address a = (address)o;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  write_u8((u8)a);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  write_u4((u4)a);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   574
void DumpWriter::write_symbolID(Symbol* s) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   575
  address a = (address)((uintptr_t)s);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   576
#ifdef _LP64
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   577
  write_u8((u8)a);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   578
#else
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   579
  write_u4((u4)a);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   580
#endif
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   581
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   582
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   583
void DumpWriter::write_id(u4 x) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   584
#ifdef _LP64
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   585
  write_u8((u8) x);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   586
#else
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   587
  write_u4(x);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   588
#endif
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   589
}
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   590
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
// We use java mirror as the class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
void DumpWriter::write_classID(Klass* k) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  write_objectID(k->java_mirror());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
// Support class with a collection of functions used when dumping the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
class DumperSupport : AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  // write a header of the given type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  static void write_header(DumpWriter* writer, hprofTag tag, u4 len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  // returns hprof tag for the given type signature
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   607
  static hprofTag sig2tag(Symbol* sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  // returns hprof tag for the given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  static hprofTag type2tag(BasicType type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  // returns the size of the instance of the given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   612
  static u4 instance_size(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  // dump a jfloat
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  static void dump_float(DumpWriter* writer, jfloat f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  // dump a jdouble
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  static void dump_double(DumpWriter* writer, jdouble d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  // dumps the raw value of the given field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  static void dump_field_value(DumpWriter* writer, char type, address addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  // dumps static fields of the given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   621
  static void dump_static_fields(DumpWriter* writer, Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  // dump the raw values of the instance fields of the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  static void dump_instance_fields(DumpWriter* writer, oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  // dumps the definition of the instance fields for a given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   625
  static void dump_instance_field_descriptors(DumpWriter* writer, Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  // creates HPROF_GC_INSTANCE_DUMP record for the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  static void dump_instance(DumpWriter* writer, oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  // creates HPROF_GC_CLASS_DUMP record for the given class and each of its
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  // array classes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   630
  static void dump_class_and_array_classes(DumpWriter* writer, Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  // creates HPROF_GC_CLASS_DUMP record for a given primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  // class (and each multi-dimensional array class too)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   633
  static void dump_basic_type_array_class(DumpWriter* writer, Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  // creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  static void dump_object_array(DumpWriter* writer, objArrayOop array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  // creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  static void dump_prim_array(DumpWriter* writer, typeArrayOop array);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
   639
  // create HPROF_FRAME record for the given method and bci
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   640
  static void dump_stack_frame(DumpWriter* writer, int frame_serial_num, int class_serial_num, Method* m, int bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
// write a header of the given type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
void DumperSupport:: write_header(DumpWriter* writer, hprofTag tag, u4 len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  writer->write_u1((u1)tag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  writer->write_u4(0);                  // current ticks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  writer->write_u4(len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
// returns hprof tag for the given type signature
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   651
hprofTag DumperSupport::sig2tag(Symbol* sig) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  switch (sig->byte_at(0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    case JVM_SIGNATURE_CLASS    : return HPROF_NORMAL_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    case JVM_SIGNATURE_ARRAY    : return HPROF_NORMAL_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    case JVM_SIGNATURE_BYTE     : return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    case JVM_SIGNATURE_CHAR     : return HPROF_CHAR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
    case JVM_SIGNATURE_FLOAT    : return HPROF_FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    case JVM_SIGNATURE_DOUBLE   : return HPROF_DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    case JVM_SIGNATURE_INT      : return HPROF_INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    case JVM_SIGNATURE_LONG     : return HPROF_LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
    case JVM_SIGNATURE_SHORT    : return HPROF_SHORT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    case JVM_SIGNATURE_BOOLEAN  : return HPROF_BOOLEAN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
hprofTag DumperSupport::type2tag(BasicType type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    case T_BYTE     : return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    case T_CHAR     : return HPROF_CHAR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    case T_FLOAT    : return HPROF_FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    case T_DOUBLE   : return HPROF_DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    case T_INT      : return HPROF_INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    case T_LONG     : return HPROF_LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    case T_SHORT    : return HPROF_SHORT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    case T_BOOLEAN  : return HPROF_BOOLEAN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    default : ShouldNotReachHere(); /* to shut up compiler */ return HPROF_BYTE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
// dump a jfloat
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
void DumperSupport::dump_float(DumpWriter* writer, jfloat f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  if (g_isnan(f)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    writer->write_u4(0x7fc00000);    // collapsing NaNs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
      int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
      float f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    } u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
    u.f = (float)f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    writer->write_u4((u4)u.i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
// dump a jdouble
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
void DumperSupport::dump_double(DumpWriter* writer, jdouble d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
    jlong l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
    double d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  } u;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  if (g_isnan(d)) {                 // collapsing NaNs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    u.l = (jlong)(0x7ff80000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    u.l = (u.l << 32);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    u.d = (double)d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  writer->write_u8((u8)u.l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
// dumps the raw value of the given field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
void DumperSupport::dump_field_value(DumpWriter* writer, char type, address addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    case JVM_SIGNATURE_CLASS :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    case JVM_SIGNATURE_ARRAY : {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   715
      oop o;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   716
      if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   717
        o = oopDesc::load_decode_heap_oop((narrowOop*)addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   718
      } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   719
        o = oopDesc::load_decode_heap_oop((oop*)addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   720
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      // reflection and sun.misc.Unsafe classes may have a reference to a
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   723
      // Klass* so filter it out.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   724
      assert(o->is_oop_or_null(), "should always be an oop");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
      writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
    case JVM_SIGNATURE_BYTE     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
      jbyte* b = (jbyte*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
      writer->write_u1((u1)*b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    case JVM_SIGNATURE_CHAR     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
      jchar* c = (jchar*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
      writer->write_u2((u2)*c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
    case JVM_SIGNATURE_SHORT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
      jshort* s = (jshort*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
      writer->write_u2((u2)*s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
    case JVM_SIGNATURE_FLOAT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
      jfloat* f = (jfloat*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
      dump_float(writer, *f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    case JVM_SIGNATURE_DOUBLE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
      jdouble* f = (jdouble*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
      dump_double(writer, *f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    case JVM_SIGNATURE_INT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
      jint* i = (jint*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
      writer->write_u4((u4)*i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    case JVM_SIGNATURE_LONG     : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
      jlong* l = (jlong*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
      writer->write_u8((u8)*l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    case JVM_SIGNATURE_BOOLEAN : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
      jboolean* b = (jboolean*)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
      writer->write_u1((u1)*b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
// returns the size of the instance of the given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   773
u4 DumperSupport::instance_size(Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  int size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
    if (!fld.access_flags().is_static()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   781
      Symbol* sig = fld.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
      switch (sig->byte_at(0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
        case JVM_SIGNATURE_CLASS   :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
        case JVM_SIGNATURE_ARRAY   : size += oopSize; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
        case JVM_SIGNATURE_BYTE    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
        case JVM_SIGNATURE_BOOLEAN : size += 1; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
        case JVM_SIGNATURE_CHAR    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
        case JVM_SIGNATURE_SHORT   : size += 2; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
        case JVM_SIGNATURE_INT     :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
        case JVM_SIGNATURE_FLOAT   : size += 4; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
        case JVM_SIGNATURE_LONG    :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
        case JVM_SIGNATURE_DOUBLE  : size += 8; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
        default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  return (u4)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
// dumps static fields of the given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   806
void DumperSupport::dump_static_fields(DumpWriter* writer, Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  // pass 1 - count the static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  u2 field_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
    if (fldc.access_flags().is_static()) field_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  writer->write_u2(field_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  // pass 2 - dump the field descriptors and raw values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
    if (fld.access_flags().is_static()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   821
      Symbol* sig = fld.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   823
      writer->write_symbolID(fld.name());   // name
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
      writer->write_u1(sig2tag(sig));       // type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
      // value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
      int offset = fld.offset();
8726
7bafcf0e5bfb 7029509: nightly failures after static fields in Class
never
parents: 8295
diff changeset
   828
      address addr = (address)ikh->java_mirror() + offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
      dump_field_value(writer, sig->byte_at(0), addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
// dump the raw values of the instance fields of the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
void DumperSupport::dump_instance_fields(DumpWriter* writer, oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), o->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  for (FieldStream fld(ikh, false, false); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
    if (!fld.access_flags().is_static()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   842
      Symbol* sig = fld.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
      address addr = (address)o + fld.offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      dump_field_value(writer, sig->byte_at(0), addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
// dumps the definition of the instance fields for a given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   851
void DumperSupport::dump_instance_field_descriptors(DumpWriter* writer, Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  instanceKlassHandle ikh = instanceKlassHandle(Thread::current(), k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  // pass 1 - count the instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  u2 field_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  for (FieldStream fldc(ikh, true, true); !fldc.eos(); fldc.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    if (!fldc.access_flags().is_static()) field_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  writer->write_u2(field_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  // pass 2 - dump the field descriptors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  for (FieldStream fld(ikh, true, true); !fld.eos(); fld.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
    if (!fld.access_flags().is_static()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   866
      Symbol* sig = fld.signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
   868
      writer->write_symbolID(fld.name());                   // name
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
      writer->write_u1(sig2tag(sig));       // type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
// creates HPROF_GC_INSTANCE_DUMP record for the given object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
void DumperSupport::dump_instance(DumpWriter* writer, oop o) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   876
  Klass* k = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  writer->write_u1(HPROF_GC_INSTANCE_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  // class ID
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   883
  writer->write_classID(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  // number of bytes that follow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  writer->write_u4(instance_size(k) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  // field values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  dump_instance_fields(writer, o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
// creates HPROF_GC_CLASS_DUMP record for the given class and each of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
// its array classes
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   894
void DumperSupport::dump_class_and_array_classes(DumpWriter* writer, Klass* k) {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   895
  Klass* klass = k;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   896
  assert(klass->oop_is_instance(), "not an InstanceKlass");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   897
  InstanceKlass* ik = (InstanceKlass*)klass;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  // class ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  writer->write_classID(ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  // super class ID
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   906
  Klass* java_super = ik->java_super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  if (java_super == NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   908
    writer->write_objectID(oop(NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  } else {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   910
    writer->write_classID(java_super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  writer->write_objectID(ik->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  writer->write_objectID(ik->signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  writer->write_objectID(ik->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  // reserved
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   918
  writer->write_objectID(oop(NULL));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   919
  writer->write_objectID(oop(NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  writer->write_u4(DumperSupport::instance_size(k));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  // size of constant pool - ignored by HAT 1.1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  writer->write_u2(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  // number of static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  dump_static_fields(writer, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  // description of instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  dump_instance_field_descriptors(writer, k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  // array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  while (k != NULL) {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   936
    Klass* klass = k;
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   937
    assert(klass->oop_is_objArray(), "not an ObjArrayKlass");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
    writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
    writer->write_classID(klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
    writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
    // super class of array classes is java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
    java_super = klass->java_super();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    assert(java_super != NULL, "checking");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   946
    writer->write_classID(java_super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    writer->write_objectID(ik->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
    writer->write_objectID(ik->signers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
    writer->write_objectID(ik->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   952
    writer->write_objectID(oop(NULL));    // reserved
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   953
    writer->write_objectID(oop(NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
    writer->write_u4(0);             // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
    writer->write_u2(0);             // constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
    writer->write_u2(0);             // static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    writer->write_u2(0);             // instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
    // get the array class for the next rank
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
// creates HPROF_GC_CLASS_DUMP record for a given primitive array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
// class (and each multi-dimensional array class too)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   966
void DumperSupport::dump_basic_type_array_class(DumpWriter* writer, Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
 // array classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
 while (k != NULL) {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   969
    Klass* klass = k;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
    writer->write_u1(HPROF_GC_CLASS_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
    writer->write_classID(klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
    writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
    // super class of array classes is java.lang.Object
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   976
    Klass* java_super = klass->java_super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
    assert(java_super != NULL, "checking");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   978
    writer->write_classID(java_super);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   980
    writer->write_objectID(oop(NULL));    // loader
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   981
    writer->write_objectID(oop(NULL));    // signers
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   982
    writer->write_objectID(oop(NULL));    // protection domain
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   984
    writer->write_objectID(oop(NULL));    // reserved
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   985
    writer->write_objectID(oop(NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
    writer->write_u4(0);             // instance size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    writer->write_u2(0);             // constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    writer->write_u2(0);             // static fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
    writer->write_u2(0);             // instance fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    // get the array class for the next rank
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
// creates HPROF_GC_OBJ_ARRAY_DUMP record for the given object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
void DumperSupport::dump_object_array(DumpWriter* writer, objArrayOop array) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  writer->write_u1(HPROF_GC_OBJ_ARRAY_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  writer->write_objectID(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  writer->write_u4((u4)array->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  // array class ID
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1005
  writer->write_classID(array->klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  // [id]* elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  for (int index=0; index<array->length(); index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    oop o = array->obj_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    writer->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
#define WRITE_ARRAY(Array, Type, Size) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  for (int i=0; i<Array->length(); i++) { writer->write_##Size((Size)array->Type##_at(i)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
// creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
void DumperSupport::dump_prim_array(DumpWriter* writer, typeArrayOop array) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  1020
  BasicType type = TypeArrayKlass::cast(array->klass())->element_type();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  writer->write_u1(HPROF_GC_PRIM_ARRAY_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  writer->write_objectID(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  writer->write_u4(STACK_TRACE_ID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  writer->write_u4((u4)array->length());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  writer->write_u1(type2tag(type));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  // nothing to copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  if (array->length() == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  // If the byte ordering is big endian then we can copy most types directly
202
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
  1034
  int length_in_bytes = array->length() * type2aelembytes(type);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  assert(length_in_bytes > 0, "nothing to copy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  switch (type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    case T_INT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
        WRITE_ARRAY(array, int, u4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
        writer->write_raw((void*)(array->int_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
    case T_BYTE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
      writer->write_raw((void*)(array->byte_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
    case T_CHAR : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
        WRITE_ARRAY(array, char, u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
        writer->write_raw((void*)(array->char_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
    case T_SHORT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
        WRITE_ARRAY(array, short, u2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
        writer->write_raw((void*)(array->short_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
    case T_BOOLEAN : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
        WRITE_ARRAY(array, bool, u1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
        writer->write_raw((void*)(array->bool_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
    case T_LONG : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
      if (Bytes::is_Java_byte_ordering_different()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
        WRITE_ARRAY(array, long, u8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
        writer->write_raw((void*)(array->long_at_addr(0)), length_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
    // handle float/doubles in a special value to ensure than NaNs are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
    // written correctly. TO DO: Check if we can avoid this on processors that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
    // use IEEE 754.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
    case T_FLOAT : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
      for (int i=0; i<array->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
        dump_float( writer, array->float_at(i) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    case T_DOUBLE : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
      for (int i=0; i<array->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
        dump_double( writer, array->double_at(i) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
    default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1103
// create a HPROF_FRAME record of the given Method* and bci
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1104
void DumperSupport::dump_stack_frame(DumpWriter* writer,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1105
                                     int frame_serial_num,
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1106
                                     int class_serial_num,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1107
                                     Method* m,
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1108
                                     int bci) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1109
  int line_number;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1110
  if (m->is_native()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1111
    line_number = -3;  // native frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1112
  } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1113
    line_number = m->line_number_from_bci(bci);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1114
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1115
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1116
  write_header(writer, HPROF_FRAME, 4*oopSize + 2*sizeof(u4));
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1117
  writer->write_id(frame_serial_num);               // frame serial number
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1118
  writer->write_symbolID(m->name());                // method's name
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1119
  writer->write_symbolID(m->signature());           // method's signature
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1120
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13952
diff changeset
  1121
  assert(m->method_holder()->oop_is_instance(), "not InstanceKlass");
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13952
diff changeset
  1122
  writer->write_symbolID(m->method_holder()->source_file_name());  // source file name
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1123
  writer->write_u4(class_serial_num);               // class serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1124
  writer->write_u4((u4) line_number);               // line number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1125
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1127
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
// Support class used to generate HPROF_UTF8 records from the entries in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
// SymbolTable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1131
class SymbolTableDumper : public SymbolClosure {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  SymbolTableDumper(DumpWriter* writer)     { _writer = writer; }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1137
  void do_symbol(Symbol** p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1140
void SymbolTableDumper::do_symbol(Symbol** p) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  ResourceMark rm;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1142
  Symbol* sym = load_symbol(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  int len = sym->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  if (len > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
    char* s = sym->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
    DumperSupport::write_header(writer(), HPROF_UTF8, oopSize + len);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1147
    writer()->write_symbolID(sym);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
    writer()->write_raw(s, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
// Support class used to generate HPROF_GC_ROOT_JNI_LOCAL records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
class JNILocalsDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  u4 _thread_serial_num;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1158
  int _frame_num;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  JNILocalsDumper(DumpWriter* writer, u4 thread_serial_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
    _thread_serial_num = thread_serial_num;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1164
    _frame_num = -1;  // default - empty stack
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1166
  void set_frame_number(int n) { _frame_num = n; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1168
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
void JNILocalsDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  // ignore null or deleted handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  oop o = *obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  if (o != NULL && o != JNIHandles::deleted_handle()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
    writer()->write_u1(HPROF_GC_ROOT_JNI_LOCAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
    writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
    writer()->write_u4(_thread_serial_num);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1179
    writer()->write_u4((u4)_frame_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
// Support class used to generate HPROF_GC_ROOT_JNI_GLOBAL records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
class JNIGlobalsDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  JNIGlobalsDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
  void do_oop(oop* obj_p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1196
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
void JNIGlobalsDumper::do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
  oop o = *obj_p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  // ignore these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
  if (o == NULL || o == JNIHandles::deleted_handle()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  // we ignore global ref to symbols and other internal objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  if (o->is_instance() || o->is_objArray() || o->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    writer()->write_u1(HPROF_GC_ROOT_JNI_GLOBAL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
    writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    writer()->write_objectID((oopDesc*)obj_p);      // global ref ID
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
// Support class used to generate HPROF_GC_ROOT_MONITOR_USED records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
class MonitorUsedDumper : public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  MonitorUsedDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  void do_oop(oop* obj_p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
    writer()->write_u1(HPROF_GC_ROOT_MONITOR_USED);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
    writer()->write_objectID(*obj_p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
  1228
  void do_oop(narrowOop* obj_p) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
// Support class used to generate HPROF_GC_ROOT_STICKY_CLASS records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1234
class StickyClassDumper : public KlassClosure {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  DumpWriter* writer() const                { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  StickyClassDumper(DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1242
  void do_klass(Klass* k) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1243
    if (k->oop_is_instance()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1244
      InstanceKlass* ik = InstanceKlass::cast(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
        writer()->write_u1(HPROF_GC_ROOT_STICKY_CLASS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
        writer()->write_classID(ik);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1249
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
class VM_HeapDumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
// Support class using when iterating over the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
class HeapObjectDumper : public ObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  VM_HeapDumper* _dumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  DumpWriter* _writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  VM_HeapDumper* dumper()               { return _dumper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  DumpWriter* writer()                  { return _writer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  // used to indicate that a record has been writen
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  void mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  HeapObjectDumper(VM_HeapDumper* dumper, DumpWriter* writer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
    _dumper = dumper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
    _writer = writer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  // called for each object in the heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  void do_object(oop o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
void HeapObjectDumper::do_object(oop o) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  // hide the sentinel for deleted handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  if (o == JNIHandles::deleted_handle()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
  // skip classes as these emitted as HPROF_GC_CLASS_DUMP records
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4101
diff changeset
  1282
  if (o->klass() == SystemDictionary::Class_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
    if (!java_lang_Class::is_primitive(o)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  // create a HPROF_GC_INSTANCE record for each object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  if (o->is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    DumperSupport::dump_instance(writer(), o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
    mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
    // create a HPROF_GC_OBJ_ARRAY_DUMP record for each object array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
    if (o->is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
      DumperSupport::dump_object_array(writer(), objArrayOop(o));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
      mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
      // create a HPROF_GC_PRIM_ARRAY_DUMP record for each type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
      if (o->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
        DumperSupport::dump_prim_array(writer(), typeArrayOop(o));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
        mark_end_of_record();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
// The VM operation that performs the heap dump
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
class VM_HeapDumper : public VM_GC_Operation {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
 private:
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1310
  static VM_HeapDumper* _global_dumper;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1311
  static DumpWriter*    _global_writer;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1312
  DumpWriter*           _local_writer;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1313
  JavaThread*           _oome_thread;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1314
  Method*               _oome_constructor;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  bool _gc_before_heap_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  bool _is_segmented_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  jlong _dump_start;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1318
  GrowableArray<Klass*>* _klass_map;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1319
  ThreadStackTrace** _stack_traces;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1320
  int _num_threads;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1322
  // accessors and setters
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1323
  static VM_HeapDumper* dumper()         {  assert(_global_dumper != NULL, "Error"); return _global_dumper; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1324
  static DumpWriter* writer()            {  assert(_global_writer != NULL, "Error"); return _global_writer; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1325
  void set_global_dumper() {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1326
    assert(_global_dumper == NULL, "Error");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1327
    _global_dumper = this;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1328
  }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1329
  void set_global_writer() {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1330
    assert(_global_writer == NULL, "Error");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1331
    _global_writer = _local_writer;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1332
  }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1333
  void clear_global_dumper() { _global_dumper = NULL; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1334
  void clear_global_writer() { _global_writer = NULL; }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1335
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  bool is_segmented_dump() const                { return _is_segmented_dump; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
  void set_segmented_dump()                     { _is_segmented_dump = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
  jlong dump_start() const                      { return _dump_start; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  void set_dump_start(jlong pos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  bool skip_operation() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  // writes a HPROF_LOAD_CLASS record
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1344
  static void do_load_class(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  // writes a HPROF_GC_CLASS_DUMP record for the given class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  // (and each array class too)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1348
  static void do_class_dump(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  // writes a HPROF_GC_CLASS_DUMP records for a given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  // array (and each multi-dimensional array too)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1352
  static void do_basic_type_array_class_dump(Klass* k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  // HPROF_GC_ROOT_THREAD_OBJ records
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1355
  int do_thread(JavaThread* thread, u4 thread_serial_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  void do_threads();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1358
  void add_class_serial_number(Klass* k, int serial_num) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1359
    _klass_map->at_put_grow(serial_num, k);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1360
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1361
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1362
  // HPROF_TRACE and HPROF_FRAME records
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1363
  void dump_stack_traces();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1364
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  // writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  void write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  // fixes up the length of the current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  void write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  // fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  // record in the case of a segmented heap dump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  void end_of_dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
 public:
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1376
  VM_HeapDumper(DumpWriter* writer, bool gc_before_heap_dump, bool oome) :
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
    VM_GC_Operation(0 /* total collections,      dummy, ignored */,
8295
a2b2a8a3aaee 7015169: GC Cause not always set
brutisso
parents: 8076
diff changeset
  1378
                    GCCause::_heap_dump /* GC Cause */,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
                    0 /* total full collections, dummy, ignored */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
                    gc_before_heap_dump) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1381
    _local_writer = writer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    _gc_before_heap_dump = gc_before_heap_dump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
    _is_segmented_dump = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
    _dump_start = (jlong)-1;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
  1385
    _klass_map = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<Klass*>(INITIAL_CLASS_COUNT, true);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1386
    _stack_traces = NULL;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1387
    _num_threads = 0;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1388
    if (oome) {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1389
      assert(!Thread::current()->is_VM_thread(), "Dump from OutOfMemoryError cannot be called by the VMThread");
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1390
      // get OutOfMemoryError zero-parameter constructor
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1391
      InstanceKlass* oome_ik = InstanceKlass::cast(SystemDictionary::OutOfMemoryError_klass());
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1392
      _oome_constructor = oome_ik->find_method(vmSymbols::object_initializer_name(),
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1393
                                                          vmSymbols::void_method_signature());
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1394
      // get thread throwing OOME when generating the heap dump at OOME
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1395
      _oome_thread = JavaThread::current();
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1396
    } else {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1397
      _oome_thread = NULL;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1398
      _oome_constructor = NULL;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1399
    }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1400
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1401
  ~VM_HeapDumper() {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1402
    if (_stack_traces != NULL) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1403
      for (int i=0; i < _num_threads; i++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1404
        delete _stack_traces[i];
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1405
      }
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
  1406
      FREE_C_HEAP_ARRAY(ThreadStackTrace*, _stack_traces, mtInternal);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1407
    }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1408
    delete _klass_map;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
  VMOp_Type type() const { return VMOp_HeapDumper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
  // used to mark sub-record boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
  void check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  void doit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1417
VM_HeapDumper* VM_HeapDumper::_global_dumper = NULL;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1418
DumpWriter*    VM_HeapDumper::_global_writer = NULL;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1419
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
bool VM_HeapDumper::skip_operation() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
// sets the dump starting position
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
void VM_HeapDumper::set_dump_start(jlong pos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
  _dump_start = pos;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
 // writes a HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
void VM_HeapDumper::write_dump_header() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
      writer()->write_u1(HPROF_HEAP_DUMP_SEGMENT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
      writer()->write_u1(HPROF_HEAP_DUMP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    writer()->write_u4(0); // current ticks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    // record the starting position for the dump (its length will be fixed up later)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
    set_dump_start(writer()->current_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
// fixes up the length of the current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
void VM_HeapDumper::write_current_dump_record_length() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
    assert(dump_start() >= 0, "no dump start recorded");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
    // calculate the size of the dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    jlong dump_end = writer()->current_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
    jlong dump_len = (dump_end - dump_start() - 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
    // record length must fit in a u4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    if (dump_len > (jlong)(4L*(jlong)G)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
      warning("record is too large");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    // seek to the dump start and fix-up the length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
    writer()->seek_to_offset(dump_start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    writer()->write_u4((u4)dump_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
    // adjust the total size written to keep the bytes written correct.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    writer()->adjust_bytes_written(-((long) sizeof(u4)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
    // seek to dump end so we can continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
    writer()->seek_to_offset(dump_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
    // no current dump record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
    set_dump_start((jlong)-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
// used on a sub-record boundary to check if we need to start a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
// new segment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
void VM_HeapDumper::check_segment_length() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
      // don't use current_offset that would be too expensive on a per record basis
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
      jlong dump_end = writer()->bytes_written() + writer()->bytes_unwritten();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
      assert(dump_end == writer()->current_offset(), "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
      jlong dump_len = (dump_end - dump_start() - 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
      assert(dump_len >= 0 && dump_len <= max_juint, "bad dump length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
      if (dump_len > (jlong)HeapDumpSegmentSize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
        write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
        write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
// fixes up the current dump record )and writes HPROF_HEAP_DUMP_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
// record in the case of a segmented heap dump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
void VM_HeapDumper::end_of_dump() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  if (writer()->is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
    write_current_dump_record_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
    // for segmented dump we write the end record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
    if (is_segmented_dump()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
      writer()->write_u1(HPROF_HEAP_DUMP_END);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
      writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
      writer()->write_u4(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
// marks sub-record boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
void HeapObjectDumper::mark_end_of_record() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
  dumper()->check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
// writes a HPROF_LOAD_CLASS record for the class (and each of its
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
// array classes)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1515
void VM_HeapDumper::do_load_class(Klass* k) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  static u4 class_serial_num = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  // len of HPROF_LOAD_CLASS record
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  u4 remaining = 2*oopSize + 2*sizeof(u4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  // write a HPROF_LOAD_CLASS for the class and each array class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  do {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1523
    DumperSupport::write_header(writer(), HPROF_LOAD_CLASS, remaining);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
    // class serial number is just a number
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1526
    writer()->write_u4(++class_serial_num);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    // class ID
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1529
    Klass* klass = k;
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1530
    writer()->write_classID(klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1532
    // add the Klass* and class serial number pair
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1533
    dumper()->add_class_serial_number(klass, class_serial_num);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1534
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1535
    writer()->write_u4(STACK_TRACE_ID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    // class name ID
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1538
    Symbol* name = klass->name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1539
    writer()->write_symbolID(name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    // write a LOAD_CLASS record for the array type (if it exists)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
    k = klass->array_klass_or_null();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
  } while (k != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
// writes a HPROF_GC_CLASS_DUMP record for the given class
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1547
void VM_HeapDumper::do_class_dump(Klass* k) {
20675
ae7f1f0b5e11 8024425: VM_HeapDumper doesn't put anonymous classes in the heap dump
sla
parents: 20282
diff changeset
  1548
  if (k->oop_is_instance()) {
ae7f1f0b5e11 8024425: VM_HeapDumper doesn't put anonymous classes in the heap dump
sla
parents: 20282
diff changeset
  1549
    DumperSupport::dump_class_and_array_classes(writer(), k);
ae7f1f0b5e11 8024425: VM_HeapDumper doesn't put anonymous classes in the heap dump
sla
parents: 20282
diff changeset
  1550
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
// writes a HPROF_GC_CLASS_DUMP records for a given basic type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
// array (and each multi-dimensional array too)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1555
void VM_HeapDumper::do_basic_type_array_class_dump(Klass* k) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1556
  DumperSupport::dump_basic_type_array_class(writer(), k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
// Walk the stack of the given thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
// Dumps a HPROF_GC_ROOT_JAVA_FRAME record for each local
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
// Dumps a HPROF_GC_ROOT_JNI_LOCAL record for each JNI local
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1562
//
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1563
// It returns the number of Java frames in this thread stack
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1564
int VM_HeapDumper::do_thread(JavaThread* java_thread, u4 thread_serial_num) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  JNILocalsDumper blk(writer(), thread_serial_num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  oop threadObj = java_thread->threadObj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  assert(threadObj != NULL, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1570
  int stack_depth = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  if (java_thread->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
    // vframes are resource allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    Thread* current_thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    ResourceMark rm(current_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    HandleMark hm(current_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    RegisterMap reg_map(java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
    frame f = java_thread->last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
    vframe* vf = vframe::new_vframe(&f, &reg_map, java_thread);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1581
    frame* last_entry_frame = NULL;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1582
    int extra_frames = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1584
    if (java_thread == _oome_thread && _oome_constructor != NULL) {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1585
      extra_frames++;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1586
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
    while (vf != NULL) {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1588
      blk.set_frame_number(stack_depth);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
      if (vf->is_java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
        // java frame (interpreted, compiled, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
        javaVFrame *jvf = javaVFrame::cast(vf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
        if (!(jvf->method()->is_native())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
          StackValueCollection* locals = jvf->locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
          for (int slot=0; slot<locals->size(); slot++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
            if (locals->at(slot)->type() == T_OBJECT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
              oop o = locals->obj_at(slot)();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
              if (o != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
                writer()->write_u1(HPROF_GC_ROOT_JAVA_FRAME);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
                writer()->write_objectID(o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
                writer()->write_u4(thread_serial_num);
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1603
                writer()->write_u4((u4) (stack_depth + extra_frames));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
          }
22895
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1607
          StackValueCollection *exprs = jvf->expressions();
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1608
          for(int index = 0; index < exprs->size(); index++) {
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1609
            if (exprs->at(index)->type() == T_OBJECT) {
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1610
               oop o = exprs->obj_at(index)();
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1611
               if (o != NULL) {
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1612
                 writer()->write_u1(HPROF_GC_ROOT_JAVA_FRAME);
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1613
                 writer()->write_objectID(o);
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1614
                 writer()->write_u4(thread_serial_num);
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1615
                 writer()->write_u4((u4) (stack_depth + extra_frames));
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1616
               }
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1617
             }
52fbddf39901 8034867: Object references from expression stack are not visible as roots via jvmti FollowReferences and HeapDump
sspitsyn
parents: 20675
diff changeset
  1618
          }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1619
        } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1620
          // native frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1621
          if (stack_depth == 0) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1622
            // JNI locals for the top frame.
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1623
            java_thread->active_handles()->oops_do(&blk);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1624
          } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1625
            if (last_entry_frame != NULL) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1626
              // JNI locals for the entry frame
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1627
              assert(last_entry_frame->is_entry_frame(), "checking");
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1628
              last_entry_frame->entry_frame_call_wrapper()->handles()->oops_do(&blk);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1629
            }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1630
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
        }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1632
        // increment only for Java frames
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1633
        stack_depth++;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1634
        last_entry_frame = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1636
      } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
        // externalVFrame - if it's an entry frame then report any JNI locals
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1638
        // as roots when we find the corresponding native javaVFrame
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
        frame* fr = vf->frame_pointer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
        assert(fr != NULL, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
        if (fr->is_entry_frame()) {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1642
          last_entry_frame = fr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
      vf = vf->sender();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
    }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1647
  } else {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1648
    // no last java frame but there may be JNI locals
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1649
    java_thread->active_handles()->oops_do(&blk);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1651
  return stack_depth;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
// write a HPROF_GC_ROOT_THREAD_OBJ record for each java thread. Then walk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
// the stack so that locals and JNI locals are dumped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
void VM_HeapDumper::do_threads() {
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1658
  for (int i=0; i < _num_threads; i++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1659
    JavaThread* thread = _stack_traces[i]->thread();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
    oop threadObj = thread->threadObj();
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1661
    u4 thread_serial_num = i+1;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1662
    u4 stack_serial_num = thread_serial_num + STACK_TRACE_ID;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1663
    writer()->write_u1(HPROF_GC_ROOT_THREAD_OBJ);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1664
    writer()->write_objectID(threadObj);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1665
    writer()->write_u4(thread_serial_num);  // thread number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1666
    writer()->write_u4(stack_serial_num);   // stack trace serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1667
    int num_frames = do_thread(thread, thread_serial_num);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1668
    assert(num_frames == _stack_traces[i]->get_stack_depth(),
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1669
           "total number of Java frames not matched");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
// The VM operation that dumps the heap. The dump consists of the following
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
// records:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
//  HPROF_HEADER
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
//  [HPROF_UTF8]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
//  [HPROF_LOAD_CLASS]*
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1680
//  [[HPROF_FRAME]*|HPROF_TRACE]*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
//  [HPROF_GC_CLASS_DUMP]*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
//  HPROF_HEAP_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
//
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1684
// The HPROF_TRACE records represent the stack traces where the heap dump
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1685
// is generated and a "dummy trace" record which does not include
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1686
// any frames. The dummy trace record is used to be referenced as the
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1687
// unknown object alloc site.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
// The HPROF_HEAP_DUMP record has a length following by sub-records. To allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
// the heap dump be generated in a single pass we remember the position of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
// the dump length and fix it up after all sub-records have been written.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
// To generate the sub-records we iterate over the heap, writing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
// HPROF_GC_INSTANCE_DUMP, HPROF_GC_OBJ_ARRAY_DUMP, and HPROF_GC_PRIM_ARRAY_DUMP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
// records as we go. Once that is done we write records for some of the GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
// roots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
void VM_HeapDumper::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  CollectedHeap* ch = Universe::heap();
11000
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1701
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1702
  ch->ensure_parsability(false); // must happen, even if collection does
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1703
                                 // not happen (e.g. due to GC_locker)
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1704
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  if (_gc_before_heap_dump) {
11000
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1706
    if (GC_locker::is_active()) {
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1707
      warning("GC locker is held; pre-heapdump GC was skipped");
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1708
    } else {
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1709
      ch->collect_as_vm_thread(GCCause::_heap_dump);
e7c4440c05e2 7110428: Crash during HeapDump operation
poonam
parents: 9630
diff changeset
  1710
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1713
  // At this point we should be the only dumper active, so
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1714
  // the following should be safe.
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1715
  set_global_dumper();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1716
  set_global_writer();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1717
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
  // Write the file header - use 1.0.2 for large heaps, otherwise 1.0.1
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1719
  size_t used = ch->used();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
  const char* header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
  if (used > (size_t)SegmentedHeapDumpThreshold) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
    set_segmented_dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
    header = "JAVA PROFILE 1.0.2";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
    header = "JAVA PROFILE 1.0.1";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
  }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1727
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
  // header is few bytes long - no chance to overflow int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  writer()->write_raw((void*)header, (int)strlen(header));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
  writer()->write_u1(0); // terminator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  writer()->write_u4(oopSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
  writer()->write_u8(os::javaTimeMillis());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
  // HPROF_UTF8 records
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
  SymbolTableDumper sym_dumper(writer());
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7914
diff changeset
  1736
  SymbolTable::symbols_do(&sym_dumper);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  // write HPROF_LOAD_CLASS records
20675
ae7f1f0b5e11 8024425: VM_HeapDumper doesn't put anonymous classes in the heap dump
sla
parents: 20282
diff changeset
  1739
  ClassLoaderDataGraph::classes_do(&do_load_class);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
  Universe::basic_type_classes_do(&do_load_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1742
  // write HPROF_FRAME and HPROF_TRACE records
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1743
  // this must be called after _klass_map is built when iterating the classes above.
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1744
  dump_stack_traces();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1745
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
  // write HPROF_HEAP_DUMP or HPROF_HEAP_DUMP_SEGMENT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
  write_dump_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
  // Writes HPROF_GC_CLASS_DUMP records
20675
ae7f1f0b5e11 8024425: VM_HeapDumper doesn't put anonymous classes in the heap dump
sla
parents: 20282
diff changeset
  1750
  ClassLoaderDataGraph::classes_do(&do_class_dump);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
  Universe::basic_type_classes_do(&do_basic_type_array_class_dump);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
  // writes HPROF_GC_INSTANCE_DUMP records.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
  // After each sub-record is written check_segment_length will be invoked. When
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
  // generated a segmented heap dump this allows us to check if the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
  // segment exceeds a threshold and if so, then a new segment is started.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  // The HPROF_GC_CLASS_DUMP and HPROF_GC_INSTANCE_DUMP are the vast bulk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  // of the heap dump.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
  HeapObjectDumper obj_dumper(this, writer());
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1428
diff changeset
  1761
  Universe::heap()->safe_object_iterate(&obj_dumper);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  // HPROF_GC_ROOT_THREAD_OBJ + frames + jni locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
  do_threads();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
  // HPROF_GC_ROOT_MONITOR_USED
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  MonitorUsedDumper mon_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  ObjectSynchronizer::oops_do(&mon_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  // HPROF_GC_ROOT_JNI_GLOBAL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
  JNIGlobalsDumper jni_dumper(writer());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  JNIHandles::oops_do(&jni_dumper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
  check_segment_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
  // HPROF_GC_ROOT_STICKY_CLASS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
  StickyClassDumper class_dumper(writer());
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1779
  SystemDictionary::always_strong_classes_do(&class_dumper);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
  // fixes up the length of the dump record. In the case of a segmented
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
  // heap then the HPROF_HEAP_DUMP_END record is also written.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  end_of_dump();
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1784
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1785
  // Now we clear the global variables, so that a future dumper might run.
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1786
  clear_global_dumper();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1787
  clear_global_writer();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1790
void VM_HeapDumper::dump_stack_traces() {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1791
  // write a HPROF_TRACE record without any frames to be referenced as object alloc sites
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1792
  DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4));
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1793
  writer()->write_u4((u4) STACK_TRACE_ID);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1794
  writer()->write_u4(0);                    // thread number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1795
  writer()->write_u4(0);                    // frame count
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1796
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
  1797
  _stack_traces = NEW_C_HEAP_ARRAY(ThreadStackTrace*, Threads::number_of_threads(), mtInternal);
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1798
  int frame_serial_num = 0;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1799
  for (JavaThread* thread = Threads::first(); thread != NULL ; thread = thread->next()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1800
    oop threadObj = thread->threadObj();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1801
    if (threadObj != NULL && !thread->is_exiting() && !thread->is_hidden_from_external_view()) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1802
      // dump thread stack trace
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1803
      ThreadStackTrace* stack_trace = new ThreadStackTrace(thread, false);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1804
      stack_trace->dump_stack_at_safepoint(-1);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1805
      _stack_traces[_num_threads++] = stack_trace;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1806
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1807
      // write HPROF_FRAME records for this thread's stack trace
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1808
      int depth = stack_trace->get_stack_depth();
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1809
      int thread_frame_start = frame_serial_num;
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1810
      int extra_frames = 0;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1811
      // write fake frame that makes it look like the thread, which caused OOME,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1812
      // is in the OutOfMemoryError zero-parameter constructor
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1813
      if (thread == _oome_thread && _oome_constructor != NULL) {
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1814
        int oome_serial_num = _klass_map->find(_oome_constructor->method_holder());
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1815
        // the class serial number starts from 1
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1816
        assert(oome_serial_num > 0, "OutOfMemoryError class not found");
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1817
        DumperSupport::dump_stack_frame(writer(), ++frame_serial_num, oome_serial_num,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1818
                                        _oome_constructor, 0);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1819
        extra_frames++;
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1820
      }
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1821
      for (int j=0; j < depth; j++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1822
        StackFrameInfo* frame = stack_trace->stack_frame_at(j);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1823
        Method* m = frame->method();
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1824
        int class_serial_num = _klass_map->find(m->method_holder());
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1825
        // the class serial number starts from 1
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1826
        assert(class_serial_num > 0, "class not found");
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1827
        DumperSupport::dump_stack_frame(writer(), ++frame_serial_num, class_serial_num, m, frame->bci());
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1828
      }
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1829
      depth += extra_frames;
1428
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1830
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1831
      // write HPROF_TRACE record for one thread
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1832
      DumperSupport::write_header(writer(), HPROF_TRACE, 3*sizeof(u4) + depth*oopSize);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1833
      int stack_serial_num = _num_threads + STACK_TRACE_ID;
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1834
      writer()->write_u4(stack_serial_num);      // stack trace serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1835
      writer()->write_u4((u4) _num_threads);     // thread serial number
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1836
      writer()->write_u4(depth);                 // frame count
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1837
      for (int j=1; j <= depth; j++) {
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1838
        writer()->write_id(thread_frame_start + j);
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1839
      }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1840
    }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1841
  }
147c6bcaa316 6306922: Dump dump created by +HeapDumpOnOutOfMemoryError should include stack traces for stack roots
mchung
parents: 1388
diff changeset
  1842
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
// dump the heap to given path.
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22895
diff changeset
  1845
PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
int HeapDumper::dump(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  assert(path != NULL && strlen(path) > 0, "path missing");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  // print message in interactive case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
    tty->print_cr("Dumping heap to %s ...", path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
    timer()->start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
  // create the dump writer. If the file can be opened then bail
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  DumpWriter writer(path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
  if (!writer.is_open()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
    set_error(writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
    if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
      tty->print_cr("Unable to create %s: %s", path,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
        (error() != NULL) ? error() : "reason unknown");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  // generate the dump
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1867
  VM_HeapDumper dumper(&writer, _gc_before_heap_dump, _oome);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1868
  if (Thread::current()->is_VM_thread()) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1869
    assert(SafepointSynchronize::is_at_safepoint(), "Expected to be called at a safepoint");
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1870
    dumper.doit();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1871
  } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1872
    VMThread::execute(&dumper);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1873
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
  // close dump file and record any error that the writer may have encountered
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  writer.close();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
  set_error(writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
  // print message in interactive case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
  if (print_to_tty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
    timer()->stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
    if (error() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
      char msg[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
      sprintf(msg, "Heap dump file created [%s bytes in %3.3f secs]",
15228
e92acc84ade3 7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents: 14488
diff changeset
  1885
        JLONG_FORMAT, timer()->seconds());
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22895
diff changeset
  1886
PRAGMA_DIAG_PUSH
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22895
diff changeset
  1887
PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
      tty->print_cr(msg, writer.bytes_written());
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22895
diff changeset
  1889
PRAGMA_DIAG_POP
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
      tty->print_cr("Dump file is incomplete: %s", writer.error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
  return (writer.error() == NULL) ? 0 : -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
// stop timer (if still active), and free any error string we might be holding
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
HeapDumper::~HeapDumper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
  if (timer()->is_active()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
    timer()->stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
  set_error(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
// returns the error string (resource allocated), or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
char* HeapDumper::error_as_C_string() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  if (error() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
    char* str = NEW_RESOURCE_ARRAY(char, strlen(error())+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
    strcpy(str, error());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
    return str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
// set the error string
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
void HeapDumper::set_error(char* error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
  if (_error != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
    os::free(_error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
  if (error == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
    _error = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
    _error = os::strdup(error);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
    assert(_error != NULL, "allocation failure");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1931
// Called by out-of-memory error reporting by a single Java thread
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1932
// outside of a JVM safepoint
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1933
void HeapDumper::dump_heap_from_oome() {
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1934
  HeapDumper::dump_heap(true);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1935
}
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1936
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1937
// Called by error reporting by a single Java thread outside of a JVM safepoint,
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1938
// or by heap dumping by the VM thread during a (GC) safepoint. Thus, these various
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1939
// callers are strictly serialized and guaranteed not to interfere below. For more
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1940
// general use, however, this method will need modification to prevent
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1941
// inteference when updating the static variables base_path and dump_file_seq below.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
void HeapDumper::dump_heap() {
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1943
  HeapDumper::dump_heap(false);
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1944
}
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1945
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  1946
void HeapDumper::dump_heap(bool oome) {
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1947
  static char base_path[JVM_MAXPATHLEN] = {'\0'};
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1948
  static uint dump_file_seq = 0;
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1949
  char* my_path;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1950
  const int max_digit_chars = 20;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1951
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1952
  const char* dump_file_name = "java_pid";
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1953
  const char* dump_file_ext  = ".hprof";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
  // The dump file defaults to java_pid<pid>.hprof in the current working
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
  // directory. HeapDumpPath=<file> can be used to specify an alternative
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
  // dump file name or a directory where dump file is created.
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1958
  if (dump_file_seq == 0) { // first time in, we initialize base_path
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1959
    // Calculate potentially longest base path and check if we have enough
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1960
    // allocated statically.
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1961
    const size_t total_length =
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1962
                      (HeapDumpPath == NULL ? 0 : strlen(HeapDumpPath)) +
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1963
                      strlen(os::file_separator()) + max_digit_chars +
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1964
                      strlen(dump_file_name) + strlen(dump_file_ext) + 1;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1965
    if (total_length > sizeof(base_path)) {
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1966
      warning("Cannot create heap dump file.  HeapDumpPath is too long.");
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1967
      return;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1968
    }
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1969
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1970
    bool use_default_filename = true;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1971
    if (HeapDumpPath == NULL || HeapDumpPath[0] == '\0') {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1972
      // HeapDumpPath=<file> not specified
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
    } else {
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1974
      strncpy(base_path, HeapDumpPath, sizeof(base_path));
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1975
      // check if the path is a directory (must exist)
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1976
      DIR* dir = os::opendir(base_path);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1977
      if (dir == NULL) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1978
        use_default_filename = false;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1979
      } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1980
        // HeapDumpPath specified a directory. We append a file separator
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1981
        // (if needed).
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1982
        os::closedir(dir);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1983
        size_t fs_len = strlen(os::file_separator());
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1984
        if (strlen(base_path) >= fs_len) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1985
          char* end = base_path;
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1986
          end += (strlen(base_path) - fs_len);
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1987
          if (strcmp(end, os::file_separator()) != 0) {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1988
            strcat(base_path, os::file_separator());
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1989
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
    }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1993
    // If HeapDumpPath wasn't a file name then we append the default name
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1994
    if (use_default_filename) {
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1995
      const size_t dlen = strlen(base_path);  // if heap dump dir specified
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1996
      jio_snprintf(&base_path[dlen], sizeof(base_path)-dlen, "%s%d%s",
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1997
                   dump_file_name, os::current_process_id(), dump_file_ext);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  1998
    }
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  1999
    const size_t len = strlen(base_path) + 1;
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
  2000
    my_path = (char*)os::malloc(len, mtInternal);
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2001
    if (my_path == NULL) {
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2002
      warning("Cannot create heap dump file.  Out of system memory.");
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2003
      return;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2004
    }
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2005
    strncpy(my_path, base_path, len);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  2006
  } else {
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  2007
    // Append a sequence number id for dumps following the first
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2008
    const size_t len = strlen(base_path) + max_digit_chars + 2; // for '.' and \0
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11000
diff changeset
  2009
    my_path = (char*)os::malloc(len, mtInternal);
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2010
    if (my_path == NULL) {
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2011
      warning("Cannot create heap dump file.  Out of system memory.");
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2012
      return;
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2013
    }
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2014
    jio_snprintf(my_path, len, "%s.%d", base_path, dump_file_seq);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  }
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  2016
  dump_file_seq++;   // increment seq number for next time we dump
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  HeapDumper dumper(false /* no GC before heap dump */,
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  2019
                    true  /* send to tty */,
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 5547
diff changeset
  2020
                    oome  /* pass along out-of-memory-error flag */);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1893
diff changeset
  2021
  dumper.dump(my_path);
7914
6a0f3ba90b09 6811367: Fix code in HeapDumper::dump_heap() to avoid buffer overrun
coleenp
parents: 7397
diff changeset
  2022
  os::free(my_path);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
}