--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/shared/oopStorageSet.hpp Wed Aug 21 18:42:30 2019 -0400
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_OOPSTORAGESET_HPP
+#define SHARE_GC_SHARED_OOPSTORAGESET_HPP
+
+#include "memory/allocation.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/macros.hpp"
+
+class OopStorage;
+
+class OopStorageSet : public AllStatic {
+private:
+ friend void oopstorage_init();
+
+ enum {
+ singular_index, // For singular iterator.
+
+ all_start,
+
+ // Strong
+ strong_start = all_start,
+ jni_global_index = strong_start,
+ vm_global_index,
+ strong_end,
+
+ // Weak
+ weak_start = strong_end,
+ jni_weak_index = weak_start,
+ vm_weak_index,
+ string_table_weak_index,
+ resolved_method_table_weak_index,
+ weak_end,
+
+ all_end = weak_end
+ };
+
+ static OopStorage* storages[all_end];
+
+ static void verify_initialized(uint index) NOT_DEBUG_RETURN;
+
+ static OopStorage* storage(uint index) {
+ verify_initialized(index);
+ return storages[index];
+ }
+
+ static void initialize();
+
+public:
+ class Iterator;
+
+ static const uint strong_count = (strong_end - strong_start);
+ static const uint weak_count = (weak_end - weak_start);
+ static const uint all_count = (all_end - all_start);
+
+ static Iterator strong_iterator();
+ static Iterator weak_iterator();
+ static Iterator all_iterator();
+
+ // Strong
+ static OopStorage* jni_global() { return storage(jni_global_index); }
+ static OopStorage* vm_global() { return storage(vm_global_index); }
+
+ // Weak
+ static OopStorage* jni_weak() { return storage(jni_weak_index); }
+ static OopStorage* vm_weak() { return storage(vm_weak_index); }
+
+ static OopStorage* string_table_weak() {
+ return storage(string_table_weak_index);
+ }
+
+ static OopStorage* resolved_method_table_weak() {
+ return storage(resolved_method_table_weak_index);
+ }
+};
+
+class OopStorageSet::Iterator {
+ friend class OopStorageSet;
+
+ enum Category { singular, strong, weak, all };
+
+ uint _index;
+ uint _limit;
+ DEBUG_ONLY(Category _category;)
+
+ Iterator(uint index, uint limit, Category category) :
+ _index(index), _limit(limit) DEBUG_ONLY(COMMA _category(category)) {}
+
+ void verify_nonsingular() const NOT_DEBUG_RETURN;
+ void verify_category_match(const Iterator& other) const NOT_DEBUG_RETURN;
+ void verify_dereferenceable() const NOT_DEBUG_RETURN;
+
+public:
+ // Construct a singular iterator for later assignment. The only valid
+ // operations are destruction and assignment.
+ Iterator() :
+ _index(singular_index),
+ _limit(singular_index)
+ DEBUG_ONLY(COMMA _category(singular)) {}
+
+ bool is_end() const {
+ verify_nonsingular();
+ return _index == _limit;
+ }
+
+ bool operator==(const Iterator& other) const {
+ verify_category_match(other);
+ return _index == other._index;
+ }
+
+ bool operator!=(const Iterator& other) const {
+ return !operator==(other);
+ }
+
+ OopStorage* operator*() const {
+ verify_dereferenceable();
+ return storage(_index);
+ }
+
+ OopStorage* operator->() const {
+ return operator*();
+ }
+
+ Iterator& operator++() {
+ verify_dereferenceable();
+ ++_index;
+ return *this;
+ }
+
+ Iterator operator++(int) {
+ Iterator result = *this;
+ operator++();
+ return result;
+ }
+
+ Iterator begin() const {
+ verify_nonsingular();
+ return *this;
+ }
+
+ Iterator end() const {
+ verify_nonsingular();
+ Iterator result = *this;
+ result._index = _limit;
+ return result;
+ }
+};
+
+inline OopStorageSet::Iterator OopStorageSet::strong_iterator() {
+ return Iterator(strong_start, strong_end, Iterator::strong);
+}
+
+inline OopStorageSet::Iterator OopStorageSet::weak_iterator() {
+ return Iterator(weak_start, weak_end, Iterator::weak);
+}
+
+inline OopStorageSet::Iterator OopStorageSet::all_iterator() {
+ return Iterator(all_start, all_end, Iterator::all);
+}
+
+#endif // SHARE_GC_SHARED_OOPSTORAGESET_HPP