src/hotspot/share/utilities/debug.cpp
author stuefe
Fri, 30 Mar 2018 06:31:16 +0200
changeset 49653 a569cb4425f3
parent 49480 d7df2dd501ce
child 49671 015af70b9a1d
permissions -rw-r--r--
8191101: Show register content in hs-err file on assert Reviewed-by: adinn, clanger, simonis
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49061
a6b6a428c915 8198635: Remove unused safepoint message functions and ShowSafepointMsgs
coleenp
parents: 47891
diff changeset
     2
 * Copyright (c) 1997, 2018, 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: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
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: 5403
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: 6967
diff changeset
    25
#include "precompiled.hpp"
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47216
diff changeset
    26
#include "jvm.h"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    28
#include "code/codeCache.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    29
#include "code/icBuffer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    30
#include "code/nmethod.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    31
#include "code/vtableStubs.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    32
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    33
#include "compiler/disassembler.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29697
diff changeset
    34
#include "gc/shared/collectedHeap.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    35
#include "interpreter/bytecodeHistogram.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    36
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    37
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    38
#include "memory/universe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    39
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    40
#include "prims/privilegedStack.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    41
#include "runtime/arguments.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 39274
diff changeset
    42
#include "runtime/atomic.hpp"
49480
d7df2dd501ce 8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents: 49061
diff changeset
    43
#include "runtime/frame.inline.hpp"
d7df2dd501ce 8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents: 49061
diff changeset
    44
#include "runtime/handles.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    45
#include "runtime/java.hpp"
25468
5331df506290 8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents: 25351
diff changeset
    46
#include "runtime/os.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    47
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    48
#include "runtime/stubCodeGenerator.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    49
#include "runtime/stubRoutines.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14076
diff changeset
    50
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    51
#include "runtime/vframe.hpp"
25715
d5a8dbdc5150 8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents: 25468
diff changeset
    52
#include "runtime/vm_version.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    53
#include "services/heapDumper.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    54
#include "utilities/defaultStream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    55
#include "utilities/events.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46408
diff changeset
    56
#include "utilities/formatBuffer.hpp"
49653
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    57
#include "utilities/globalDefinitions.hpp"
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35913
diff changeset
    58
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6967
diff changeset
    59
#include "utilities/vmError.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
38254
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
    61
#include <stdio.h>
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
    62
49653
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    63
// Support for showing register content on asserts/guarantees.
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    64
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    65
static char g_dummy;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    66
char* g_assert_poison = &g_dummy;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    67
static intx g_asserting_thread = 0;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    68
static void* g_assertion_context = NULL;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    69
#endif // CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
    70
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
#ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
#  ifdef _DEBUG
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
   // NOTE: don't turn the lines below into a comment -- if you're getting
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
   // a compile error here, change the settings to define ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
   ASSERT should be defined when _DEBUG is defined.  It is not intended to be used for debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
   functions that do not slow down the system too much and thus can be left in optimized code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
   On the other hand, the code should not be included in a production version.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
#  endif // _DEBUG
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
#ifdef _DEBUG
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
#  ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
     configuration error: ASSERT must be defined in debug version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
#  endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
#endif // _DEBUG
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
#ifdef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
#  if -defined _DEBUG || -defined ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
     configuration error: ASSERT et al. must not be defined in PRODUCT version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
#  endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 18683
diff changeset
    95
ATTRIBUTE_PRINTF(1, 2)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
void warning(const char* format, ...) {
6967
c5ebdcf8372e 6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents: 6445
diff changeset
    97
  if (PrintWarnings) {
13761
46489cdfa479 7199082: write warning messages to stderr
jcoomes
parents: 13728
diff changeset
    98
    FILE* const err = defaultStream::error_stream();
46489cdfa479 7199082: write warning messages to stderr
jcoomes
parents: 13728
diff changeset
    99
    jio_fprintf(err, "%s warning: ", VM_Version::vm_name());
6967
c5ebdcf8372e 6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents: 6445
diff changeset
   100
    va_list ap;
c5ebdcf8372e 6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents: 6445
diff changeset
   101
    va_start(ap, format);
13761
46489cdfa479 7199082: write warning messages to stderr
jcoomes
parents: 13728
diff changeset
   102
    vfprintf(err, format, ap);
6967
c5ebdcf8372e 6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents: 6445
diff changeset
   103
    va_end(ap);
13761
46489cdfa479 7199082: write warning messages to stderr
jcoomes
parents: 13728
diff changeset
   104
    fputc('\n', err);
6967
c5ebdcf8372e 6392697: Additional flag needed to supress Hotspot warning messages
kamg
parents: 6445
diff changeset
   105
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  if (BreakAtWarning) BREAKPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
#define is_token_break(ch) (isspace(ch) || (ch) == ',')
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
static const char* last_file_name = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
static int         last_line_no   = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
// assert/guarantee/... may happen very early during VM initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
// Don't rely on anything that is initialized by Threads::create_vm(). For
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
// example, don't use tty.
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   119
bool error_is_suppressed(const char* file_name, int line_no) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // The following 1-element cache requires that passed-in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // file names are always only constant literals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  if (file_name == last_file_name && line_no == last_line_no)  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  int file_name_len = (int)strlen(file_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  char separator = os::file_separator()[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  const char* base_name = strrchr(file_name, separator);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  if (base_name == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    base_name = file_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // scan the SuppressErrorAt option
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  const char* cp = SuppressErrorAt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    const char* sfile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    int sfile_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    int sline;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    bool noisy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    while ((*cp) != '\0' && is_token_break(*cp))  cp++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    if ((*cp) == '\0')  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    sfile = cp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    while ((*cp) != '\0' && !is_token_break(*cp) && (*cp) != ':')  cp++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    sfile_len = cp - sfile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    if ((*cp) == ':')  cp++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    sline = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    while ((*cp) != '\0' && isdigit(*cp)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      sline *= 10;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
      sline += (*cp) - '0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
      cp++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    // "file:line!" means the assert suppression is not silent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    noisy = ((*cp) == '!');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    while ((*cp) != '\0' && !is_token_break(*cp))  cp++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    // match the line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    if (sline != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      if (sline != line_no)  continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    // match the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    if (sfile_len > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
      const char* look = file_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
      const char* look_max = file_name + file_name_len - sfile_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
      const char* foundp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
      bool match = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
      while (!match
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
             && (foundp = strchr(look, sfile[0])) != NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
             && foundp <= look_max) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
        match = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
        for (int i = 1; i < sfile_len; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
          if (sfile[i] != foundp[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
            match = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
        look = foundp + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
      if (!match)  continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    // got a match!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    if (noisy) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      fdStream out(defaultStream::output_fd());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
      out.print_raw("[error suppressed at ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
      out.print_raw(base_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      char buf[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      jio_snprintf(buf, sizeof(buf), ":%d]", line_no);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      out.print_raw_cr(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      // update 1-element cache for fast silent matches
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
      last_file_name = file_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
      last_line_no   = line_no;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46560
diff changeset
   192
  if (!VMError::is_error_reported() && !SuppressFatalErrorMessage) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    // print a friendly hint:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    fdStream out(defaultStream::output_fd());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    out.print_raw_cr("# To suppress the following error report, specify this argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    out.print_raw   ("# after -XX: or in .hotspotrc:  SuppressErrorAt=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    out.print_raw   (base_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    char buf[16];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    jio_snprintf(buf, sizeof(buf), ":%d", line_no);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    out.print_raw_cr(buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
#undef is_token_break
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
// Place-holder for non-existent suppression check:
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   210
#define error_is_suppressed(file_name, line_no) (false)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   212
#endif // !PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   214
void report_vm_error(const char* file, int line, const char* error_msg)
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   215
{
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   216
  report_vm_error(file, line, error_msg, "%s", "");
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   217
}
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   218
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   219
void report_vm_error(const char* file, int line, const char* error_msg, const char* detail_fmt, ...)
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   220
{
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   221
  if (Debugging || error_is_suppressed(file, line)) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   222
  va_list detail_args;
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   223
  va_start(detail_args, detail_fmt);
49653
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   224
  void* context = NULL;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   225
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   226
  if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   227
    context = g_assertion_context;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   228
  }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   229
#endif // CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   230
  VMError::report_and_die(Thread::current_or_null(), context, file, line, error_msg, detail_fmt, detail_args);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   231
  va_end(detail_args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
37113
5a33bf5089ac 8148425: strerror() function is not thread-safe
stuefe
parents: 36384
diff changeset
   234
void report_vm_status_error(const char* file, int line, const char* error_msg,
5a33bf5089ac 8148425: strerror() function is not thread-safe
stuefe
parents: 36384
diff changeset
   235
                            int status, const char* detail) {
5a33bf5089ac 8148425: strerror() function is not thread-safe
stuefe
parents: 36384
diff changeset
   236
  report_vm_error(file, line, error_msg, "error %s(%d), %s", os::errno_name(status), status, detail);
5a33bf5089ac 8148425: strerror() function is not thread-safe
stuefe
parents: 36384
diff changeset
   237
}
5a33bf5089ac 8148425: strerror() function is not thread-safe
stuefe
parents: 36384
diff changeset
   238
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   239
void report_fatal(const char* file, int line, const char* detail_fmt, ...)
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   240
{
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   241
  if (Debugging || error_is_suppressed(file, line)) return;
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   242
  va_list detail_args;
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   243
  va_start(detail_args, detail_fmt);
49653
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   244
  void* context = NULL;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   245
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   246
  if (g_assertion_context != NULL && os::current_thread_id() == g_asserting_thread) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   247
    context = g_assertion_context;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   248
  }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   249
#endif // CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   250
  VMError::report_and_die(Thread::current_or_null(), context, file, line, "fatal error", detail_fmt, detail_args);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   251
  va_end(detail_args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   254
void report_vm_out_of_memory(const char* file, int line, size_t size,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   255
                             VMErrorType vm_err_type, const char* detail_fmt, ...) {
7719
ef138e2849eb 6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents: 7433
diff changeset
   256
  if (Debugging) return;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   257
  va_list detail_args;
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   258
  va_start(detail_args, detail_fmt);
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34144
diff changeset
   259
  VMError::report_and_die(Thread::current_or_null(), file, line, size, vm_err_type, detail_fmt, detail_args);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   260
  va_end(detail_args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
15796
41577a5deb58 6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents: 15088
diff changeset
   262
  // The UseOSErrorReporting option in report_and_die() may allow a return
41577a5deb58 6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents: 15088
diff changeset
   263
  // to here. If so then we'll have to figure out how to handle it.
41577a5deb58 6799919: Recursive calls to report_vm_out_of_memory are handled incorrectly
dcubed
parents: 15088
diff changeset
   264
  guarantee(false, "report_and_die() should not return here");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   267
void report_should_not_call(const char* file, int line) {
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   268
  report_vm_error(file, line, "ShouldNotCall()");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   271
void report_should_not_reach_here(const char* file, int line) {
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   272
  report_vm_error(file, line, "ShouldNotReachHere()");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   275
void report_unimplemented(const char* file, int line) {
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   276
  report_vm_error(file, line, "Unimplemented()");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
38254
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   279
#ifdef ASSERT
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   280
bool is_executing_unit_tests() {
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   281
  return ExecutingUnitTests;
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   282
}
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   283
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   284
void report_assert_msg(const char* msg, ...) {
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   285
  va_list ap;
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   286
  va_start(ap, msg);
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   287
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   288
  fprintf(stderr, "assert failed: %s\n", err_msg(FormatBufferDummy(), msg, ap).buffer());
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   289
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   290
  va_end(ap);
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   291
}
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   292
#endif // ASSERT
05e46b580b4e 8149591: Prepare hotspot for GTest
iignatyev
parents: 37466
diff changeset
   293
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   294
void report_untested(const char* file, int line, const char* message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
#ifndef PRODUCT
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 3908
diff changeset
   296
  warning("Untested: %s in %s: %d\n", message, file, line);
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   297
#endif // !PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
void report_java_out_of_memory(const char* message) {
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47216
diff changeset
   301
  static int out_of_memory_reported = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // A number of threads may attempt to report OutOfMemoryError at around the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  // same time. To avoid dumping the heap or executing the data collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // commands multiple times we just do it once when the first threads reports
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // the error.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  if (Atomic::cmpxchg(1, &out_of_memory_reported, 0) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    // create heap dump before OnOutOfMemoryError commands are executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    if (HeapDumpOnOutOfMemoryError) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
      tty->print_cr("java.lang.OutOfMemoryError: %s", message);
6445
64694b1e56e7 6765718: Indicate which thread throwing OOME when generating the heap dump at OOME
thurka
parents: 6176
diff changeset
   311
      HeapDumper::dump_heap_from_oome();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31340
diff changeset
   315
      VMError::report_java_out_of_memory(message);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    }
34670
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   317
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   318
    if (CrashOnOutOfMemoryError) {
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   319
      tty->print_cr("Aborting due to java.lang.OutOfMemoryError: %s", message);
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   320
      fatal("OutOfMemory encountered: %s", message);
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   321
    }
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   322
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   323
    if (ExitOnOutOfMemoryError) {
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   324
      tty->print_cr("Terminating due to java.lang.OutOfMemoryError: %s", message);
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   325
      os::exit(3);
5ab871b40190 8138745: Implement ExitOnOutOfMemory and CrashOnOutOfMemory in HotSpot
kevinw
parents: 34633
diff changeset
   326
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
// ------ helper functions for debugging go here ------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
// All debug entries should be wrapped with a stack allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
// Command object. It makes sure a resource mark is set and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
// flushes the logfile to prevent file sharing problems.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
class Command : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  ResetNoHandleMark rnhm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  HandleMark   hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  bool debug_save;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  static int level;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  Command(const char* str) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    debug_save = Debugging;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    Debugging = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    if (level++ > 0)  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    tty->print_cr("\"Executing %s\"", str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   352
  ~Command() {
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   353
        tty->flush();
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   354
        Debugging = debug_save;
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   355
        level--;
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   356
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
int Command::level = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   361
#ifndef PRODUCT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   362
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
extern "C" void blob(CodeBlob* cb) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  Command c("blob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  cb->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
extern "C" void dump_vtable(address p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  Command c("dump_vtable");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   371
  Klass* k = (Klass*)p;
46408
70aab0c2ea8b 8178350: klassVtable and klassItable should be ValueObj
iklam
parents: 42650
diff changeset
   372
  k->vtable().print();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
extern "C" void nm(intptr_t p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // Actually we look through all CodeBlobs (the nm name has been kept for backwards compatability)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  Command c("nm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  CodeBlob* cb = CodeCache::find_blob((address)p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  if (cb == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    tty->print_cr("NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    cb->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
extern "C" void disnm(intptr_t p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  Command c("disnm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  CodeBlob* cb = CodeCache::find_blob((address) p);
35542
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   391
  if (cb != NULL) {
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   392
    nmethod* nm = cb->as_nmethod_or_null();
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   393
    if (nm != NULL) {
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   394
      nm->print();
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   395
    } else {
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   396
      cb->print();
9dccb7f9f656 8071374: -XX:+PrintAssembly -XX:+PrintSignatureHandlers crash fastdebug VM with assert(limit == __null || limit <= nm->code_end()) in RelocIterator::initialize
vlivanov
parents: 35061
diff changeset
   397
    }
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7397
diff changeset
   398
    Disassembler::decode(cb);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7397
diff changeset
   399
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
extern "C" void printnm(intptr_t p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  char buffer[256];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  sprintf(buffer, "printnm: " INTPTR_FORMAT, p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  Command c(buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  CodeBlob* cb = CodeCache::find_blob((address) p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  if (cb->is_nmethod()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    nmethod* nm = (nmethod*)cb;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    nm->print_nmethod(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
extern "C" void universe() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  Command c("universe");
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 34670
diff changeset
   417
  Universe::print_on(tty);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
extern "C" void verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  // try to run a verify on the entire system
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  // note: this may not be safe if we're not at a safepoint; for debugging,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  // this manipulates the safepoint settings to avoid assertion failures
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  Command c("universe verify");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  bool safe = SafepointSynchronize::is_at_safepoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  if (!safe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    tty->print_cr("warning: not at safepoint -- verify may fail");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    SafepointSynchronize::set_is_at_safepoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  // Ensure Eden top is correct before verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  Universe::heap()->prepare_for_verify();
14076
84643cfaeaa8 8000831: Heap verification output incorrect/incomplete
johnc
parents: 13761
diff changeset
   433
  Universe::verify();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  if (!safe) SafepointSynchronize::set_is_not_at_safepoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
extern "C" void pp(void* p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  Command c("pp");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  FlagSetting fl(PrintVMMessages, true);
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   441
  FlagSetting f2(DisplayVMOutput, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  if (Universe::heap()->is_in(p)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    oop obj = oop(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
    obj->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  } else {
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33135
diff changeset
   446
    tty->print(PTR_FORMAT, p2i(p));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
// pv: print vm-printable object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
extern "C" void pa(intptr_t p)   { ((AllocatedObj*) p)->print(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
extern "C" void findpc(intptr_t x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   455
#endif // !PRODUCT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   456
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
extern "C" void ps() { // print stack
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34144
diff changeset
   458
  if (Thread::current_or_null() == NULL) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  Command c("ps");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // Prints the stack of the current Java thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  JavaThread* p = JavaThread::active();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  tty->print(" for thread: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  p->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  if (p->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    // If the last_Java_fp is set we are in C land and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    // can call the standard stack_trace function.
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   471
#ifdef PRODUCT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   472
    p->print_stack();
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   473
  } else {
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   474
    tty->print_cr("Cannot find the last Java frame, printing stack disabled.");
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   475
#else // !PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    p->trace_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    frame f = os::current_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    RegisterMap reg_map(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    f = f.sender(&reg_map);
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33135
diff changeset
   481
    tty->print("(guessing starting frame id=" PTR_FORMAT " based on current fp)\n", p2i(f.id()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    p->trace_stack_from(vframe::new_vframe(&f, &reg_map, p));
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46560
diff changeset
   483
    f.pd_ps();
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   484
#endif // PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   489
extern "C" void pfl() {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   490
  // print frame layout
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   491
  Command c("pfl");
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   492
  JavaThread* p = JavaThread::active();
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   493
  tty->print(" for thread: ");
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   494
  p->print();
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   495
  tty->cr();
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   496
  if (p->has_last_Java_frame()) {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   497
    p->print_frame_layout();
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   498
  }
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8921
diff changeset
   499
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   501
#ifndef PRODUCT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   502
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
extern "C" void psf() { // print stack frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    Command c("psf");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    JavaThread* p = JavaThread::active();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    tty->print(" for thread: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    p->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    if (p->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
      p->trace_frames();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
extern "C" void threads() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  Command c("threads");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  Threads::print(false, true);
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
extern "C" void psd() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  Command c("psd");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  SystemDictionary::print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   528
#endif // !PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
extern "C" void pss() { // print all stacks
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34144
diff changeset
   531
  if (Thread::current_or_null() == NULL) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  Command c("pss");
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   533
  Threads::print(true, PRODUCT_ONLY(false) NOT_PRODUCT(true));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   536
#ifndef PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
extern "C" void debug() {               // to set things up for compiler debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  Command c("debug");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  WizardMode = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  PrintVMMessages = PrintCompilation = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  PrintInlining = PrintAssembly = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  tty->flush();
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
extern "C" void ndebug() {              // undo debug()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  Command c("ndebug");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  PrintCompilation = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  PrintInlining = PrintAssembly = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  tty->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
extern "C" void flush()  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  Command c("flush");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  tty->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
   560
extern "C" void events() {
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
   561
  Command c("events");
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
   562
  Events::print();
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
   563
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   565
extern "C" Method* findm(intptr_t pc) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  Command c("findm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  nmethod* nm = CodeCache::find_nmethod((address)pc);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   568
  return (nm == NULL) ? (Method*)NULL : nm->method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
extern "C" nmethod* findnm(intptr_t addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  Command c("findnm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  return  CodeCache::find_nmethod((address)addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
// Another interface that isn't ambiguous in dbx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
// Can we someday rename the other find to hsfind?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
extern "C" void hsfind(intptr_t x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  Command c("hsfind");
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
   581
  os::print_location(tty, x, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
extern "C" void find(intptr_t x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  Command c("find");
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
   587
  os::print_location(tty, x, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
extern "C" void findpc(intptr_t x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  Command c("findpc");
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
   593
  os::print_location(tty, x, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   597
// Need method pointer to find bcp, when not in permgen.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   598
extern "C" void findbcp(intptr_t method, intptr_t bcp) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   599
  Command c("findbcp");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   600
  Method* mh = (Method*)method;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   601
  if (!mh->is_native()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   602
    tty->print_cr("bci_from(%p) = %d; print_codes():",
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   603
                        mh, mh->bci_from(address(bcp)));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   604
    mh->print_codes_on(tty);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   605
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   606
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   607
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
// int versions of all methods to avoid having to type type casts in the debugger
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
void pp(intptr_t p)          { pp((void*)p); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
void pp(oop p)               { pp((void*)p); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
void help() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  Command c("help");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  tty->print_cr("basic");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  tty->print_cr("  pp(void* p)   - try to make sense of p");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  tty->print_cr("  pv(intptr_t p)- ((PrintableResourceObj*) p)->print()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  tty->print_cr("  ps()          - print current thread stack");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  tty->print_cr("  pss()         - print all thread stacks");
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   620
  tty->print_cr("  pm(int pc)    - print Method* given compiled PC");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13393
diff changeset
   621
  tty->print_cr("  findm(intptr_t pc) - finds Method*");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  tty->print_cr("  find(intptr_t x)   - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
26821
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   623
  tty->print_cr("  pns(void* sp, void* fp, void* pc)  - print native (i.e. mixed) stack trace. E.g.");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   624
  tty->print_cr("                   pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   625
  tty->print_cr("                   pns($sp, $ebp, $pc) on Linux/x86 or");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   626
  tty->print_cr("                   pns($sp, 0, $pc)    on Linux/ppc64 or");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   627
  tty->print_cr("                   pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   628
  tty->print_cr("                 - in gdb do 'set overload-resolution off' before calling pns()");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   629
  tty->print_cr("                 - in dbx do 'frame 1' before calling pns()");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  tty->print_cr("misc.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  tty->print_cr("  flush()       - flushes the log file");
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
   633
  tty->print_cr("  events()      - dump events from ring buffers");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  tty->print_cr("compiler debugging");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  tty->print_cr("  debug()       - to set things up for compiler debugging");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  tty->print_cr("  ndebug()      - undo debug");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
26821
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   641
extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   642
  Command c("pns");
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   643
  static char buf[O_BUFLEN];
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34144
diff changeset
   644
  Thread* t = Thread::current_or_null();
26821
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   645
  // Call generic frame constructor (certain arguments may be ignored)
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   646
  frame fr(sp, fp, pc);
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46408
diff changeset
   647
  VMError::print_native_stack(tty, fr, t, buf, sizeof(buf));
26821
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   648
}
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   649
47891
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   650
//
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   651
// This version of pns() will not work when called from the debugger, but is
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   652
// useful when called from within hotspot code. The advantages over pns()
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   653
// are not having to pass in any arguments, and it will work on Windows/x64.
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   654
//
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   655
// WARNING: Only intended for use when debugging. Do not leave calls to
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   656
// pns2() in committed source (product or debug).
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   657
//
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   658
extern "C" void pns2() { // print native stack
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   659
  Command c("pns2");
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   660
  static char buf[O_BUFLEN];
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   661
  if (os::platform_print_native_stack(tty, NULL, buf, sizeof(buf))) {
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   662
    // We have printed the native stack in platform-specific code,
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   663
    // so nothing else to do in this case.
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   664
  } else {
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   665
    Thread* t = Thread::current_or_null();
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   666
    frame fr = os::current_frame();
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   667
    VMError::print_native_stack(tty, fr, t, buf, sizeof(buf));
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   668
  }
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   669
}
fa736014cf28 8191049: Add alternate version of pns() that is callable from within hotspot source
cjplummer
parents: 47765
diff changeset
   670
26821
ce9f82507dc2 8058345: Refactor native stack printing from vmError.cpp to debug.cpp to make it available in gdb as well
simonis
parents: 25715
diff changeset
   671
#endif // !PRODUCT
31340
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   672
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   673
//////////////////////////////////////////////////////////////////////////////
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   674
// Test multiple STATIC_ASSERT forms in various scopes.
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   675
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   676
#ifndef PRODUCT
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   677
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   678
// namespace scope
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   679
STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   680
STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   681
STATIC_ASSERT(1 == 1);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   682
STATIC_ASSERT(0 == 0);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   683
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   684
void test_multiple_static_assert_forms_in_function_scope() {
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   685
  STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   686
  STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   687
  STATIC_ASSERT(0 == 0);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   688
  STATIC_ASSERT(1 == 1);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   689
}
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   690
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   691
// class scope
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   692
struct TestMultipleStaticAssertFormsInClassScope {
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   693
  STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   694
  STATIC_ASSERT(true);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   695
  STATIC_ASSERT(0 == 0);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   696
  STATIC_ASSERT(1 == 1);
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   697
};
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   698
2f9ff278bb13 8086027: Multiple STATIC_ASSERTs at class scope doesn't work
kbarrett
parents: 30764
diff changeset
   699
#endif // !PRODUCT
49653
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   700
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   701
// Support for showing register content on asserts/guarantees.
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   702
#ifdef CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   703
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   704
static ucontext_t g_stored_assertion_context;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   705
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   706
void initialize_assert_poison() {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   707
  char* page = os::reserve_memory(os::vm_page_size());
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   708
  if (page) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   709
    if (os::commit_memory(page, os::vm_page_size(), false) &&
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   710
        os::protect_memory(page, os::vm_page_size(), os::MEM_PROT_NONE)) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   711
      g_assert_poison = page;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   712
    }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   713
  }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   714
}
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   715
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   716
static bool store_context(const void* context) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   717
  if (memcpy(&g_stored_assertion_context, context, sizeof(ucontext_t)) == false) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   718
    return false;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   719
  }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   720
#if defined(__linux) && defined(PPC64)
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   721
  // on Linux ppc64, ucontext_t contains pointers into itself which have to be patched up
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   722
  //  after copying the context (see comment in sys/ucontext.h):
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   723
  *((void**) &g_stored_assertion_context.uc_mcontext.regs) = &(g_stored_assertion_context.uc_mcontext.gp_regs);
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   724
#endif
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   725
  return true;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   726
}
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   727
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   728
bool handle_assert_poison_fault(const void* ucVoid, const void* faulting_address) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   729
  if (faulting_address == g_assert_poison) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   730
    // Disarm poison page.
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   731
    os::protect_memory((char*)g_assert_poison, os::vm_page_size(), os::MEM_PROT_RWX);
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   732
    // Store Context away.
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   733
    if (ucVoid) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   734
      const jlong my_tid = os::current_thread_id();
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   735
      if (Atomic::cmpxchg(my_tid, &g_asserting_thread, (intx)0) == 0) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   736
        if (store_context(ucVoid)) {
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   737
          g_assertion_context = &g_stored_assertion_context;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   738
        }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   739
      }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   740
    }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   741
    return true;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   742
  }
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   743
  return false;
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   744
}
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   745
#endif // CAN_SHOW_REGISTERS_ON_ASSERT
a569cb4425f3 8191101: Show register content in hs-err file on assert
stuefe
parents: 49480
diff changeset
   746