1 /*
2 * Copyright (c) 2022, Red Hat, Inc. All rights reserved.
3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef SHARE_RUNTIME_LOCKSTACK_HPP
27 #define SHARE_RUNTIME_LOCKSTACK_HPP
28
29 #include "oops/oopsHierarchy.hpp"
30 #include "utilities/globalDefinitions.hpp"
31 #include "utilities/sizes.hpp"
32
33 class JavaThread;
34 class OopClosure;
35 class outputStream;
36
37 class LockStack {
38 friend class VMStructs;
39 private:
40 static const int CAPACITY = 8;
41
42 // TODO: It would be very useful if JavaThread::lock_stack_offset() and friends were constexpr,
43 // but this is currently not the case because we're using offset_of() which is non-constexpr,
44 // GCC would warn about non-standard-layout types if we were using offsetof() (which *is* constexpr).
45 static const int lock_stack_offset;
46 static const int lock_stack_top_offset;
47 static const int lock_stack_base_offset;
48
49 // The offset of the next element, in bytes, relative to the JavaThread structure.
50 // We do this instead of a simple index into the array because this allows for
51 // efficient addressing in generated code.
52 uint32_t _top;
53 oop _base[CAPACITY];
54
55 // Get the owning thread of this lock-stack.
56 inline JavaThread* get_thread() const;
57
58 // Tests if the calling thread is the thread that owns this lock-stack.
59 bool is_owning_thread() const;
60
61 // Verifies consistency of the lock-stack.
62 void verify(const char* msg) const PRODUCT_RETURN;
63
64 // Given an offset (in bytes) calculate the index into the lock-stack.
65 static inline int to_index(uint32_t offset);
66
67 public:
68 static ByteSize top_offset() { return byte_offset_of(LockStack, _top); }
69 static ByteSize base_offset() { return byte_offset_of(LockStack, _base); }
70
71 LockStack(JavaThread* jt);
72
73 // The boundary indicies of the lock-stack.
74 static uint32_t start_offset();
75 static uint32_t end_offset();
76
77 // Return true if we have room to push onto this lock-stack, false otherwise.
78 inline bool can_push() const;
79
80 // Pushes an oop on this lock-stack.
81 inline void push(oop o);
82
83 // Pops an oop from this lock-stack.
84 inline oop pop();
85
86 // Removes an oop from an arbitrary location of this lock-stack.
87 inline void remove(oop o);
88
89 // Tests whether the oop is on this lock-stack.
90 inline bool contains(oop o) const;
91
92 // GC support
93 inline void oops_do(OopClosure* cl);
94
95 // Printing
96 void print_on(outputStream* st);
97 };
98
99 #endif // SHARE_RUNTIME_LOCKSTACK_HPP
|
1 /*
2 * Copyright (c) 2022, Red Hat, Inc. All rights reserved.
3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
4 * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 *
7 * This code is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 only, as
9 * published by the Free Software Foundation.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 *
25 */
26
27 #ifndef SHARE_RUNTIME_LOCKSTACK_HPP
28 #define SHARE_RUNTIME_LOCKSTACK_HPP
29
30 #include "oops/oopsHierarchy.hpp"
31 #include "utilities/globalDefinitions.hpp"
32 #include "utilities/sizes.hpp"
33
34 class JavaThread;
35 class OopClosure;
36 class outputStream;
37 template<typename>
38 class GrowableArray;
39
40 class LockStack {
41 friend class LockStackTest;
42 friend class VMStructs;
43 JVMCI_ONLY(friend class JVMCIVMStructs;)
44 public:
45 static const int CAPACITY = 8;
46 private:
47
48 // TODO: It would be very useful if JavaThread::lock_stack_offset() and friends were constexpr,
49 // but this is currently not the case because we're using offset_of() which is non-constexpr,
50 // GCC would warn about non-standard-layout types if we were using offsetof() (which *is* constexpr).
51 static const int lock_stack_offset;
52 static const int lock_stack_top_offset;
53 static const int lock_stack_base_offset;
54
55 // The offset of the next element, in bytes, relative to the JavaThread structure.
56 // We do this instead of a simple index into the array because this allows for
57 // efficient addressing in generated code.
58 uint32_t _top;
59 // The _bad_oop_sentinel acts as a sentinel value to elide underflow checks in generated code.
60 // The correct layout is statically asserted in the constructor.
61 const uintptr_t _bad_oop_sentinel = badOopVal;
62 oop _base[CAPACITY];
63
64 // Get the owning thread of this lock-stack.
65 inline JavaThread* get_thread() const;
66
67 // Tests if the calling thread is the thread that owns this lock-stack.
68 bool is_owning_thread() const;
69
70 // Verifies consistency of the lock-stack.
71 void verify(const char* msg) const PRODUCT_RETURN;
72
73 // Given an offset (in bytes) calculate the index into the lock-stack.
74 static inline int to_index(uint32_t offset);
75
76 public:
77 static ByteSize top_offset() { return byte_offset_of(LockStack, _top); }
78 static ByteSize base_offset() { return byte_offset_of(LockStack, _base); }
79
80 LockStack(JavaThread* jt);
81
82 // The boundary indicies of the lock-stack.
83 static uint32_t start_offset();
84 static uint32_t end_offset();
85
86 // Returns true if the lock-stack is full. False otherwise.
87 inline bool is_full() const;
88
89 // Pushes an oop on this lock-stack.
90 inline void push(oop o);
91
92 // Get the oldest oop from this lock-stack.
93 // Precondition: This lock-stack must not be empty.
94 inline oop bottom() const;
95
96 // Is the lock-stack empty.
97 inline bool is_empty() const;
98
99 // Check if object is recursive.
100 // Precondition: This lock-stack must contain the oop.
101 inline bool is_recursive(oop o) const;
102
103 // Try recursive enter.
104 // Precondition: This lock-stack must not be full.
105 inline bool try_recursive_enter(oop o);
106
107 // Try recursive exit.
108 // Precondition: This lock-stack must contain the oop.
109 inline bool try_recursive_exit(oop o);
110
111 // Removes an oop from an arbitrary location of this lock-stack.
112 // Precondition: This lock-stack must contain the oop.
113 // Returns the number of oops removed.
114 inline size_t remove(oop o);
115
116 // Tests whether the oop is on this lock-stack.
117 inline bool contains(oop o) const;
118
119 // GC support
120 inline void oops_do(OopClosure* cl);
121
122 // Printing
123 void print_on(outputStream* st);
124
125 // Verify Lock Stack consistent with lock order
126 void verify_consistent_lock_order(GrowableArray<oop>& lock_order, bool leaf_frame) const NOT_DEBUG_RETURN;
127 };
128
129 #endif // SHARE_RUNTIME_LOCKSTACK_HPP
|