1 /*
2 * Copyright (c) 1997, 2019, 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 #ifndef SHARE_RUNTIME_VFRAME_HPP
26 #define SHARE_RUNTIME_VFRAME_HPP
27
28 #include "code/debugInfo.hpp"
29 #include "code/debugInfoRec.hpp"
30 #include "code/location.hpp"
31 #include "oops/oop.hpp"
32 #include "runtime/frame.hpp"
33 #include "runtime/stackValue.hpp"
34 #include "runtime/stackValueCollection.hpp"
35 #include "utilities/growableArray.hpp"
36
37 // vframes are virtual stack frames representing source level activations.
38 // A single frame may hold several source level activations in the case of
39 // optimized code. The debugging stored with the optimized code enables
40 // us to unfold a frame as a stack of vframes.
41 // A cVFrame represents an activation of a non-java method.
42
43 // The vframe inheritance hierarchy:
44 // - vframe
45 // - javaVFrame
46 // - interpretedVFrame
47 // - compiledVFrame ; (used for both compiled Java methods and native stubs)
48 // - externalVFrame
49 // - entryVFrame ; special frame created when calling Java from C
50
51 // - BasicLock
224 static entryVFrame* cast(vframe* vf) {
225 assert(vf == NULL || vf->is_entry_frame(), "must be entry frame");
226 return (entryVFrame*) vf;
227 }
228
229 #ifndef PRODUCT
230 public:
231 // printing
232 void print_value() const;
233 void print();
234 #endif
235 friend class vframe;
236 };
237
238
239 // A MonitorInfo is a ResourceObject that describes a the pair:
240 // 1) the owner of the monitor
241 // 2) the monitor lock
242 class MonitorInfo : public ResourceObj {
243 private:
244 oop _owner; // the object owning the monitor
245 BasicLock* _lock;
246 oop _owner_klass; // klass (mirror) if owner was scalar replaced
247 bool _eliminated;
248 bool _owner_is_scalar_replaced;
249 public:
250 // Constructor
251 MonitorInfo(oop owner, BasicLock* lock, bool eliminated, bool owner_is_scalar_replaced) {
252 if (!owner_is_scalar_replaced) {
253 _owner = owner;
254 _owner_klass = NULL;
255 } else {
256 assert(eliminated, "monitor should be eliminated for scalar replaced object");
257 _owner = NULL;
258 _owner_klass = owner;
259 }
260 _lock = lock;
261 _eliminated = eliminated;
262 _owner_is_scalar_replaced = owner_is_scalar_replaced;
263 }
264 // Accessors
265 oop owner() const {
266 assert(!_owner_is_scalar_replaced, "should not be called for scalar replaced object");
267 return _owner;
268 }
269 oop owner_klass() const {
270 assert(_owner_is_scalar_replaced, "should not be called for not scalar replaced object");
271 return _owner_klass;
272 }
273 BasicLock* lock() const { return _lock; }
274 bool eliminated() const { return _eliminated; }
275 bool owner_is_scalar_replaced() const { return _owner_is_scalar_replaced; }
276 };
277
278 class vframeStreamCommon : StackObj {
279 protected:
280 // common
281 frame _prev_frame;
282 frame _frame;
283 JavaThread* _thread;
284 RegisterMap _reg_map;
285 enum { interpreted_mode, compiled_mode, at_end_mode } _mode;
286
287 // For compiled_mode
288 int _decode_offset;
289 int _sender_decode_offset;
290 int _vframe_id;
291
|
1 /*
2 * Copyright (c) 1997, 2020, 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 #ifndef SHARE_RUNTIME_VFRAME_HPP
26 #define SHARE_RUNTIME_VFRAME_HPP
27
28 #include "code/debugInfo.hpp"
29 #include "code/debugInfoRec.hpp"
30 #include "code/location.hpp"
31 #include "oops/oop.hpp"
32 #include "runtime/handles.inline.hpp"
33 #include "runtime/frame.hpp"
34 #include "runtime/stackValue.hpp"
35 #include "runtime/stackValueCollection.hpp"
36 #include "utilities/growableArray.hpp"
37
38 // vframes are virtual stack frames representing source level activations.
39 // A single frame may hold several source level activations in the case of
40 // optimized code. The debugging stored with the optimized code enables
41 // us to unfold a frame as a stack of vframes.
42 // A cVFrame represents an activation of a non-java method.
43
44 // The vframe inheritance hierarchy:
45 // - vframe
46 // - javaVFrame
47 // - interpretedVFrame
48 // - compiledVFrame ; (used for both compiled Java methods and native stubs)
49 // - externalVFrame
50 // - entryVFrame ; special frame created when calling Java from C
51
52 // - BasicLock
225 static entryVFrame* cast(vframe* vf) {
226 assert(vf == NULL || vf->is_entry_frame(), "must be entry frame");
227 return (entryVFrame*) vf;
228 }
229
230 #ifndef PRODUCT
231 public:
232 // printing
233 void print_value() const;
234 void print();
235 #endif
236 friend class vframe;
237 };
238
239
240 // A MonitorInfo is a ResourceObject that describes a the pair:
241 // 1) the owner of the monitor
242 // 2) the monitor lock
243 class MonitorInfo : public ResourceObj {
244 private:
245 Handle _owner; // the object owning the monitor
246 BasicLock* _lock;
247 Handle _owner_klass; // klass (mirror) if owner was scalar replaced
248 bool _eliminated;
249 bool _owner_is_scalar_replaced;
250 public:
251 // Constructor
252 MonitorInfo(oop owner, BasicLock* lock, bool eliminated, bool owner_is_scalar_replaced);
253 // Accessors
254 oop owner() const {
255 assert(!_owner_is_scalar_replaced, "should not be called for scalar replaced object");
256 return _owner();
257 }
258 oop owner_klass() const {
259 assert(_owner_is_scalar_replaced, "should not be called for not scalar replaced object");
260 return _owner_klass();
261 }
262 BasicLock* lock() const { return _lock; }
263 bool eliminated() const { return _eliminated; }
264 bool owner_is_scalar_replaced() const { return _owner_is_scalar_replaced; }
265 };
266
267 class vframeStreamCommon : StackObj {
268 protected:
269 // common
270 frame _prev_frame;
271 frame _frame;
272 JavaThread* _thread;
273 RegisterMap _reg_map;
274 enum { interpreted_mode, compiled_mode, at_end_mode } _mode;
275
276 // For compiled_mode
277 int _decode_offset;
278 int _sender_decode_offset;
279 int _vframe_id;
280
|