1/*
2 * Copyright (c) 1997, 2015, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25
26#ifndef SHARE_VM_UTILITIES_DECODER_HPP
27#define SHARE_VM_UTILITIES_DECODER_HPP
28
29#include "memory/allocation.hpp"
30#include "runtime/mutex.hpp"
31#include "runtime/mutexLocker.hpp"
32#include "utilities/ostream.hpp"
33
34class AbstractDecoder : public CHeapObj<mtInternal> {
35public:
36  virtual ~AbstractDecoder() {}
37
38  // status code for decoding native C frame
39  enum decoder_status {
40         not_available = -10,  // real decoder is not available
41         no_error = 0,         // successfully decoded frames
42         out_of_memory,        // out of memory
43         file_invalid,         // invalid elf file
44         file_not_found,       // could not found symbol file (on windows), such as jvm.pdb or jvm.map
45         helper_func_error,    // decoding functions not found (Windows only)
46         helper_init_error     // SymInitialize failed (Windows only)
47  };
48
49  // decode an pc address to corresponding function name and an offset from the beginning of
50  // the function
51  //
52  // Note: the 'base' variant does not demangle names. The
53  // demangling that was done systematically in the 'modulepath' variant
54  // is now optional.
55  virtual bool decode(address pc, char* buf, int buflen, int* offset,
56                      const char* modulepath = NULL, bool demangle = true) = 0;
57  virtual bool decode(address pc, char* buf, int buflen, int* offset, const void* base) = 0;
58
59  // demangle a C++ symbol
60  virtual bool demangle(const char* symbol, char* buf, int buflen) = 0;
61  // if the decoder can decode symbols in vm
62  virtual bool can_decode_C_frame_in_vm() const = 0;
63
64  virtual decoder_status status() const {
65    return _decoder_status;
66  }
67
68  virtual bool has_error() const {
69    return is_error(_decoder_status);
70  }
71
72  static bool is_error(decoder_status status) {
73    return (status > 0);
74  }
75
76protected:
77  decoder_status  _decoder_status;
78};
79
80// Do nothing decoder
81class NullDecoder : public AbstractDecoder {
82public:
83  NullDecoder() {
84    _decoder_status = not_available;
85  }
86
87  virtual ~NullDecoder() {};
88
89  virtual bool decode(address pc, char* buf, int buflen, int* offset,
90                      const char* modulepath, bool demangle) {
91    return false;
92  }
93
94  virtual bool decode(address pc, char* buf, int buflen, int* offset, const void* base) {
95    return false;
96  }
97
98  virtual bool demangle(const char* symbol, char* buf, int buflen) {
99    return false;
100  }
101
102  virtual bool can_decode_C_frame_in_vm() const {
103    return false;
104  }
105};
106
107
108class Decoder : AllStatic {
109public:
110  static bool decode(address pc, char* buf, int buflen, int* offset, const char* modulepath = NULL, bool demangle = true);
111  static bool decode(address pc, char* buf, int buflen, int* offset, bool demangle) {
112    return decode(pc, buf, buflen, offset, (const char*) NULL, demangle);
113  }
114  static bool decode(address pc, char* buf, int buflen, int* offset, const void* base);
115  static bool demangle(const char* symbol, char* buf, int buflen);
116  static bool can_decode_C_frame_in_vm();
117
118  // shutdown shared instance
119  static void shutdown();
120
121  static void print_state_on(outputStream* st);
122
123protected:
124  // shared decoder instance, _shared_instance_lock is needed
125  static AbstractDecoder* get_shared_instance();
126  // a private instance for error handler. Error handler can be
127  // triggered almost everywhere, including signal handler, where
128  // no lock can be taken. So the shared decoder can not be used
129  // in this scenario.
130  static AbstractDecoder* get_error_handler_instance();
131
132  static AbstractDecoder* create_decoder();
133private:
134  static AbstractDecoder*     _shared_decoder;
135  static AbstractDecoder*     _error_handler_decoder;
136  static NullDecoder          _do_nothing_decoder;
137
138protected:
139  static Mutex*               _shared_decoder_lock;
140  static Mutex* shared_decoder_lock();
141
142  friend class DecoderLocker;
143};
144
145class DecoderLocker : public MutexLockerEx {
146  AbstractDecoder* _decoder;
147  inline bool is_first_error_thread();
148public:
149  DecoderLocker();
150  AbstractDecoder* decoder() {
151    return _decoder;
152  }
153};
154
155#endif // SHARE_VM_UTILITIES_DECODER_HPP
156