Mon, 12 Aug 2019 18:30:40 +0300
8223147: JFR Backport
8199712: Flight Recorder
8203346: JFR: Inconsistent signature of jfr_add_string_constant
8195817: JFR.stop should require name of recording
8195818: JFR.start should increase autogenerated name by one
8195819: Remove recording=x from jcmd JFR.check output
8203921: JFR thread sampling is missing fixes from JDK-8194552
8203929: Limit amount of data for JFR.dump
8203664: JFR start failure after AppCDS archive created with JFR StartFlightRecording
8003209: JFR events for network utilization
8207392: [PPC64] Implement JFR profiling
8202835: jfr/event/os/TestSystemProcess.java fails on missing events
Summary: Backport JFR from JDK11. Initial integration
Reviewed-by: neugens
1 /*
2 * Copyright (c) 1999, 2016, 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 */
25 #ifndef SHARE_VM_CI_CIINSTANCEKLASS_HPP
26 #define SHARE_VM_CI_CIINSTANCEKLASS_HPP
28 #include "ci/ciConstantPoolCache.hpp"
29 #include "ci/ciFlags.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciSymbol.hpp"
33 // ciInstanceKlass
34 //
35 // This class represents a Klass* in the HotSpot virtual machine
36 // whose Klass part is an InstanceKlass. It may or may not
37 // be loaded.
38 class ciInstanceKlass : public ciKlass {
39 CI_PACKAGE_ACCESS
40 friend class ciBytecodeStream;
41 friend class ciEnv;
42 friend class ciExceptionHandler;
43 friend class ciMethod;
44 friend class ciField;
46 private:
47 jobject _loader;
48 jobject _protection_domain;
50 InstanceKlass::ClassState _init_state; // state of class
51 bool _is_shared;
52 bool _has_finalizer;
53 bool _has_subklass;
54 bool _has_nonstatic_fields;
55 bool _has_default_methods;
56 bool _is_anonymous;
58 ciFlags _flags;
59 jint _nonstatic_field_size;
60 jint _nonstatic_oop_map_size;
62 // Lazy fields get filled in only upon request.
63 ciInstanceKlass* _super;
64 ciInstance* _java_mirror;
66 ciConstantPoolCache* _field_cache; // cached map index->field
67 GrowableArray<ciField*>* _nonstatic_fields;
69 // The possible values of the _implementor fall into following three cases:
70 // NULL: no implementor.
71 // A ciInstanceKlass that's not itself: one implementor.
72 // Itsef: more than one implementors.
73 ciInstanceKlass* _implementor;
75 GrowableArray<ciField*>* _non_static_fields;
77 protected:
78 ciInstanceKlass(KlassHandle h_k);
79 ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);
81 InstanceKlass* get_instanceKlass() const {
82 return (InstanceKlass*)get_Klass();
83 }
85 oop loader();
86 jobject loader_handle();
88 oop protection_domain();
89 jobject protection_domain_handle();
91 const char* type_string() { return "ciInstanceKlass"; }
93 bool is_in_package_impl(const char* packagename, int len);
95 void print_impl(outputStream* st);
97 ciConstantPoolCache* field_cache();
99 bool is_shared() { return _is_shared; }
101 void compute_shared_init_state();
102 bool compute_shared_has_subklass();
103 int compute_nonstatic_fields();
104 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
106 // Update the init_state for shared klasses
107 void update_if_shared(InstanceKlass::ClassState expected) {
108 if (_is_shared && _init_state != expected) {
109 if (is_loaded()) compute_shared_init_state();
110 }
111 }
113 public:
114 // Has this klass been initialized?
115 bool is_initialized() {
116 update_if_shared(InstanceKlass::fully_initialized);
117 return _init_state == InstanceKlass::fully_initialized;
118 }
119 // Is this klass being initialized?
120 bool is_being_initialized() {
121 update_if_shared(InstanceKlass::being_initialized);
122 return _init_state == InstanceKlass::being_initialized;
123 }
124 // Has this klass been linked?
125 bool is_linked() {
126 update_if_shared(InstanceKlass::linked);
127 return _init_state >= InstanceKlass::linked;
128 }
130 // General klass information.
131 ciFlags flags() {
132 assert(is_loaded(), "must be loaded");
133 return _flags;
134 }
135 bool has_finalizer() {
136 assert(is_loaded(), "must be loaded");
137 return _has_finalizer; }
138 bool has_subklass() {
139 assert(is_loaded(), "must be loaded");
140 if (_is_shared && !_has_subklass) {
141 if (flags().is_final()) {
142 return false;
143 } else {
144 return compute_shared_has_subklass();
145 }
146 }
147 return _has_subklass;
148 }
149 jint size_helper() {
150 return (Klass::layout_helper_size_in_bytes(layout_helper())
151 >> LogHeapWordSize);
152 }
153 jint nonstatic_field_size() {
154 assert(is_loaded(), "must be loaded");
155 return _nonstatic_field_size; }
156 jint has_nonstatic_fields() {
157 assert(is_loaded(), "must be loaded");
158 return _has_nonstatic_fields; }
159 jint nonstatic_oop_map_size() {
160 assert(is_loaded(), "must be loaded");
161 return _nonstatic_oop_map_size; }
162 ciInstanceKlass* super();
163 jint nof_implementors() {
164 ciInstanceKlass* impl;
165 assert(is_loaded(), "must be loaded");
166 impl = implementor();
167 if (impl == NULL) {
168 return 0;
169 } else if (impl != this) {
170 return 1;
171 } else {
172 return 2;
173 }
174 }
176 bool has_default_methods() {
177 assert(is_loaded(), "must be loaded");
178 return _has_default_methods;
179 }
181 bool is_anonymous() {
182 return _is_anonymous;
183 }
185 ciInstanceKlass* get_canonical_holder(int offset);
186 ciField* get_field_by_offset(int field_offset, bool is_static);
187 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);
189 GrowableArray<ciField*>* non_static_fields();
191 // total number of nonstatic fields (including inherited):
192 int nof_nonstatic_fields() {
193 if (_nonstatic_fields == NULL)
194 return compute_nonstatic_fields();
195 else
196 return _nonstatic_fields->length();
197 }
198 // nth nonstatic field (presented by ascending address)
199 ciField* nonstatic_field_at(int i) {
200 assert(_nonstatic_fields != NULL, "");
201 return _nonstatic_fields->at(i);
202 }
204 ciInstanceKlass* unique_concrete_subklass();
205 bool has_finalizable_subclass();
207 bool contains_field_offset(int offset) {
208 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
209 }
211 // Get the instance of java.lang.Class corresponding to
212 // this klass. This instance is used for locking of
213 // synchronized static methods of this klass.
214 ciInstance* java_mirror();
216 // Java access flags
217 bool is_public () { return flags().is_public(); }
218 bool is_final () { return flags().is_final(); }
219 bool is_super () { return flags().is_super(); }
220 bool is_interface () { return flags().is_interface(); }
221 bool is_abstract () { return flags().is_abstract(); }
223 ciMethod* find_method(ciSymbol* name, ciSymbol* signature);
224 // Note: To find a method from name and type strings, use ciSymbol::make,
225 // but consider adding to vmSymbols.hpp instead.
227 bool is_leaf_type();
228 ciInstanceKlass* implementor();
230 // Is the defining class loader of this class the default loader?
231 bool uses_default_loader() const;
233 bool is_java_lang_Object() const;
235 BasicType box_klass_type() const;
236 bool is_box_klass() const;
237 bool is_boxed_value_offset(int offset) const;
239 // Is this klass in the given package?
240 bool is_in_package(const char* packagename) {
241 return is_in_package(packagename, (int) strlen(packagename));
242 }
243 bool is_in_package(const char* packagename, int len);
245 // What kind of ciObject is this?
246 bool is_instance_klass() const { return true; }
247 bool is_java_klass() const { return true; }
249 virtual ciKlass* exact_klass() {
250 if (is_loaded() && is_final() && !is_interface()) {
251 return this;
252 }
253 return NULL;
254 }
256 ciInstanceKlass* host_klass();
258 // Dump the current state of this klass for compilation replay.
259 virtual void dump_replay_data(outputStream* out);
260 };
262 #endif // SHARE_VM_CI_CIINSTANCEKLASS_HPP