1 /* 2 * Copyright (c) 2003, 2022, 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_CLASSFILE_PLACEHOLDERS_HPP 26 #define SHARE_CLASSFILE_PLACEHOLDERS_HPP 27 28 class PlaceholderEntry; 29 class Thread; 30 class ClassLoaderData; 31 class Symbol; 32 33 // Placeholder objects. These represent classes currently 34 // being loaded, as well as arrays of primitives. 35 // 36 37 class PlaceholderTable : public AllStatic { 38 public: 39 // caller to create a placeholder entry must enumerate an action 40 // caller claims ownership of that action 41 // For parallel classloading: 42 // multiple LOAD_INSTANCE threads can proceed in parallel 43 // multiple LOAD_SUPER threads can proceed in parallel 44 // LOAD_SUPER needed to check for class circularity 45 // DEFINE_CLASS: ultimately define class must be single threaded 46 // on a class/classloader basis 47 // so the head of that queue owns the token 48 // and the rest of the threads return the result the first thread gets 49 // PRIMITIVE_OBJECT_FIELD: needed to check for inline type fields circularity 50 enum classloadAction { 51 LOAD_INSTANCE = 1, // calling load_instance_class 52 LOAD_SUPER = 2, // loading superclass for this class 53 DEFINE_CLASS = 3, // find_or_define class 54 PRIMITIVE_OBJECT_FIELD = 4 // primitive object fields 55 }; 56 57 static PlaceholderEntry* get_entry(Symbol* name, ClassLoaderData* loader_data); 58 59 // find_and_add returns probe pointer - old or new 60 // If no entry exists, add a placeholder entry and push SeenThread for classloadAction 61 // If entry exists, reuse entry and push SeenThread for classloadAction 62 static PlaceholderEntry* find_and_add(Symbol* name, ClassLoaderData* loader_data, 63 classloadAction action, Symbol* supername, 64 JavaThread* thread); 65 66 // find_and_remove first removes SeenThread for classloadAction 67 // If all queues are empty and definer is null, remove the PlacheholderEntry completely 68 static void find_and_remove(Symbol* name, ClassLoaderData* loader_data, 69 classloadAction action, JavaThread* thread); 70 71 static void print_on(outputStream* st); 72 static void print(); 73 }; 74 75 class SeenThread; 76 77 // Placeholder objects represent classes currently being loaded. 78 // All threads examining the placeholder table must hold the 79 // SystemDictionary_lock, so we don't need special precautions 80 // on store ordering here. 81 // The system dictionary is the only user of this class. 82 class PlaceholderEntry { 83 friend class PlaceholderTable; 84 private: 85 Symbol* _supername; 86 JavaThread* _definer; // owner of define token 87 InstanceKlass* _instanceKlass; // InstanceKlass from successful define 88 SeenThread* _superThreadQ; // doubly-linked queue of Threads loading a superclass for this class 89 SeenThread* _loadInstanceThreadQ; // loadInstance thread 90 // This can't be multiple threads since class loading waits for 91 // this token to be removed. 92 93 SeenThread* _defineThreadQ; // queue of Threads trying to define this class 94 // including _definer 95 // _definer owns token 96 // queue waits for and returns results from _definer 97 SeenThread* _inlineTypeFieldQ; // queue of inline types for circularity checking 98 99 SeenThread* actionToQueue(PlaceholderTable::classloadAction action); 100 void set_threadQ(SeenThread* seenthread, PlaceholderTable::classloadAction action); 101 void add_seen_thread(JavaThread* thread, PlaceholderTable::classloadAction action); 102 bool remove_seen_thread(JavaThread* thread, PlaceholderTable::classloadAction action); 103 104 public: 105 PlaceholderEntry() : 106 _supername(nullptr), _definer(nullptr), _instanceKlass(nullptr), 107 _superThreadQ(nullptr), _loadInstanceThreadQ(nullptr), _defineThreadQ(nullptr), 108 _inlineTypeFieldQ(nullptr) { } 109 110 Symbol* supername() const { return _supername; } 111 void set_supername(Symbol* supername) { 112 if (supername != _supername) { 113 Symbol::maybe_decrement_refcount(_supername); 114 _supername = supername; 115 Symbol::maybe_increment_refcount(_supername); 116 } 117 } 118 void clear_supername() { 119 Symbol::maybe_decrement_refcount(_supername); 120 _supername = nullptr; 121 } 122 123 JavaThread* definer() const {return _definer; } 124 void set_definer(JavaThread* definer) { _definer = definer; } 125 126 InstanceKlass* instance_klass() const {return _instanceKlass; } 127 void set_instance_klass(InstanceKlass* ik) { _instanceKlass = ik; } 128 129 SeenThread* superThreadQ() const { return _superThreadQ; } 130 void set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; } 131 132 SeenThread* loadInstanceThreadQ() const { return _loadInstanceThreadQ; } 133 void set_loadInstanceThreadQ(SeenThread* SeenThread) { _loadInstanceThreadQ = SeenThread; } 134 135 SeenThread* defineThreadQ() const { return _defineThreadQ; } 136 void set_defineThreadQ(SeenThread* SeenThread) { _defineThreadQ = SeenThread; } 137 138 SeenThread* inlineTypeFieldQ() const { return _inlineTypeFieldQ; } 139 void set_inlineTypeFieldQ(SeenThread* SeenThread) { _inlineTypeFieldQ = SeenThread; } 140 141 bool super_load_in_progress() { 142 return (_superThreadQ != NULL); 143 } 144 145 bool instance_load_in_progress() { 146 return (_loadInstanceThreadQ != NULL); 147 } 148 149 bool define_class_in_progress() { 150 return (_defineThreadQ != NULL); 151 } 152 153 bool inline_type_field_in_progress() { 154 return (_inlineTypeFieldQ != NULL); 155 } 156 157 // Used for ClassCircularityError checking 158 bool check_seen_thread(JavaThread* thread, PlaceholderTable::classloadAction action); 159 160 void print_on(outputStream* st) const; 161 }; 162 163 #endif // SHARE_CLASSFILE_PLACEHOLDERS_HPP