1 /*
2 * Copyright (c) 2015, 2025, 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_CDS_CLASSLISTPARSER_HPP
26 #define SHARE_CDS_CLASSLISTPARSER_HPP
27
28 #include "utilities/exceptions.hpp"
29 #include "utilities/globalDefinitions.hpp"
30 #include "utilities/growableArray.hpp"
31 #include "utilities/istream.hpp"
32 #include "utilities/resizableHashTable.hpp"
33
34 class constantPoolHandle;
35 class Thread;
36
37 class CDSIndyInfo {
38 GrowableArray<const char*>* _items;
39 public:
40 CDSIndyInfo() : _items(nullptr) {}
41 void add_item(const char* item) {
42 if (_items == nullptr) {
43 _items = new GrowableArray<const char*>(9);
44 }
45 assert(_items != nullptr, "sanity");
46 _items->append(item);
47 }
48 void add_ref_kind(int ref_kind) {
49 switch (ref_kind) {
50 case JVM_REF_getField : _items->append("REF_getField"); break;
51 case JVM_REF_getStatic : _items->append("REF_getStatic"); break;
52 case JVM_REF_putField : _items->append("REF_putField"); break;
53 case JVM_REF_putStatic : _items->append("REF_putStatic"); break;
54 case JVM_REF_invokeVirtual : _items->append("REF_invokeVirtual"); break;
55 case JVM_REF_invokeStatic : _items->append("REF_invokeStatic"); break;
56 case JVM_REF_invokeSpecial : _items->append("REF_invokeSpecial"); break;
57 case JVM_REF_newInvokeSpecial : _items->append("REF_newInvokeSpecial"); break;
58 case JVM_REF_invokeInterface : _items->append("REF_invokeInterface"); break;
59 default : ShouldNotReachHere();
60 }
61 }
62 GrowableArray<const char*>* items() {
63 return _items;
64 }
65 };
66
67 class ClassListParser : public StackObj {
68 static const char* CONSTANT_POOL_TAG;
69 static const char* LAMBDA_FORM_TAG;
70 static const char* LAMBDA_PROXY_TAG;
71
72 public:
73 static const char* LOADER_NEGATIVE_CACHE_TAG;
74
75 enum ParseMode {
76 _parse_all,
77 _parse_lambda_forms_invokers_only,
78 };
79
80 private:
81 // Must be C_HEAP allocated -- we don't want nested resource allocations.
82 typedef ResizeableHashTable<int, InstanceKlass*,
83 AnyObj::C_HEAP, mtClassShared> ID2KlassTable;
84
85 enum {
86 _unspecified = -999,
87 };
88
89 // Use a small initial size in debug build to test resizing logic
90 static const int INITIAL_TABLE_SIZE = DEBUG_ONLY(17) NOT_DEBUG(1987);
91 static const int MAX_TABLE_SIZE = 61333;
92 static volatile Thread* _parsing_thread; // the thread that created _instance
93 static ClassListParser* _instance; // the singleton.
94 const char* _classlist_file;
95
96 ID2KlassTable _id2klass_table;
97
98 FileInput _file_input;
99 inputStream _input_stream;
100 char* _line; // The buffer that holds the current line. Some characters in
101 // the buffer may be overwritten by '\0' during parsing.
102 int _line_len; // Original length of the input line.
103 const char* _class_name;
104 GrowableArray<const char*>* _indy_items; // items related to invoke dynamic for archiving lambda proxy classes
105 int _id;
106 int _super;
107 GrowableArray<int>* _interfaces;
108 bool _interfaces_specified;
109 const char* _source;
110 ParseMode _parse_mode;
111
112 bool parse_int_option(const char* option_name, int* value);
113 bool parse_uint_option(const char* option_name, int* value);
114 InstanceKlass* load_class_from_source(Symbol* class_name, TRAPS);
115 ID2KlassTable* id2klass_table() {
116 return &_id2klass_table;
117 }
118 InstanceKlass* lookup_class_by_id(int id);
119 void print_specified_interfaces();
120 void print_actual_interfaces(InstanceKlass *ik);
121 bool is_matching_cp_entry(const constantPoolHandle &pool, int cp_index, TRAPS);
122
123 InstanceKlass* find_builtin_class_helper(JavaThread* current, Symbol* class_name_symbol, oop class_loader_oop);
124 InstanceKlass* find_builtin_class(JavaThread* current, const char* class_name);
125
126 void resolve_indy(JavaThread* current, Symbol* class_name_symbol);
127 void resolve_indy_impl(Symbol* class_name_symbol, TRAPS);
128 void clean_up_input_line();
129 void read_class_name_and_attributes();
130 void parse_class_name_and_attributes(TRAPS);
131 Klass* load_current_class(Symbol* class_name_symbol, TRAPS);
132 void parse_constant_pool_tag();
133 void parse_loader_negative_cache_tag();
134
135 size_t lineno() { return _input_stream.lineno(); }
136 FILE* do_open(const char* file);
137 ClassListParser(const char* file, ParseMode _parse_mode);
138 ~ClassListParser();
139 void print_diagnostic_info(outputStream* st, const char* msg, va_list ap) ATTRIBUTE_PRINTF(3, 0);
140 void print_diagnostic_info(outputStream* st, const char* msg, ...) ATTRIBUTE_PRINTF(3, 0);
141 void constant_pool_resolution_warning(const char* msg, ...) ATTRIBUTE_PRINTF(2, 0);
142 void error(const char* msg, ...) ATTRIBUTE_PRINTF(2, 0);
143 GrowableArray<InstanceKlass*> get_specified_interfaces();
144 void check_supertype_obstruction(int specified_supertype_id, const InstanceKlass* specified_supertype, TRAPS);
145
146 public:
147 static void parse_classlist(const char* classlist_path, ParseMode parse_mode, TRAPS);
148
149 static bool is_parsing_thread();
150 static ClassListParser* instance() {
151 assert(is_parsing_thread(), "call this only in the thread that created ClassListParsing::_instance");
152 assert(_instance != nullptr, "must be");
153 return _instance;
154 }
155 static const char* lambda_proxy_tag() {
156 return LAMBDA_PROXY_TAG;
157 }
158 static const char* lambda_form_tag() {
159 return LAMBDA_FORM_TAG;
160 }
161
162 void parse(TRAPS);
163 void split_tokens_by_whitespace(int offset, GrowableArray<const char*>* items);
164 int split_at_tag_from_line();
165 void parse_at_tags(TRAPS);
166 char* _token;
167 void parse_int(int* value);
168 void parse_uint(int* value);
169 bool try_parse_uint(int* value);
170 bool skip_token(const char* option_name);
171 void skip_whitespaces();
172 void skip_non_whitespaces();
173
174 bool parse_lambda_forms_invokers_only() {
175 return _parse_mode == _parse_lambda_forms_invokers_only;
176 }
177 bool is_id_specified() {
178 return _id != _unspecified;
179 }
180 bool is_super_specified() {
181 return _super != _unspecified;
182 }
183 bool are_interfaces_specified() {
184 return _interfaces->length() > 0;
185 }
186 int id() {
187 assert(is_id_specified(), "do not query unspecified id");
188 return _id;
189 }
190 int super() {
191 assert(is_super_specified(), "do not query unspecified super");
192 return _super;
193 }
194 void check_already_loaded(const char* which, int id) {
195 if (!id2klass_table()->contains(id)) {
196 error("%s id %d is not yet loaded", which, id);
197 }
198 }
199 void check_class_name(const char* class_name);
200
201 const char* current_class_name() {
202 return _class_name;
203 }
204
205 bool is_loading_from_source();
206 static void populate_cds_indy_info(const constantPoolHandle &pool, int cp_index, CDSIndyInfo* cii, TRAPS);
207 };
208 #endif // SHARE_CDS_CLASSLISTPARSER_HPP