1 /*
2 * Copyright (c) 2023, 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 #include "precompiled.hpp"
26 #include "cds/archiveHeapLoader.hpp"
27 #include "cds/cdsEnumKlass.hpp"
28 #include "cds/heapShared.hpp"
29 #include "classfile/vmClasses.hpp"
30 #include "classfile/systemDictionaryShared.hpp"
31 #include "memory/resourceArea.hpp"
32 #include "oops/fieldStreams.inline.hpp"
33 #include "oops/oop.inline.hpp"
34 #include "runtime/fieldDescriptor.inline.hpp"
35
36 #if INCLUDE_CDS_JAVA_HEAP
37
38 bool CDSEnumKlass::is_enum_obj(oop orig_obj) {
39 Klass* k = orig_obj->klass();
40 Klass* buffered_k = ArchiveBuilder::get_buffered_klass(k);
41 return k->is_instance_klass() &&
42 InstanceKlass::cast(k)->java_super() == vmClasses::Enum_klass();
43 }
44
45 // -- Handling of Enum objects
46 // Java Enum classes have synthetic <clinit> methods that look like this
47 // enum MyEnum {FOO, BAR}
48 // MyEnum::<clinint> {
49 // /*static final MyEnum*/ MyEnum::FOO = new MyEnum("FOO");
50 // /*static final MyEnum*/ MyEnum::BAR = new MyEnum("BAR");
51 // }
52 //
53 // If MyEnum::FOO object is referenced by any of the archived subgraphs, we must
54 // ensure the archived value equals (in object address) to the runtime value of
55 // MyEnum::FOO.
56 //
57 // However, since MyEnum::<clinint> is synthetically generated by javac, there's
58 // no way of programmatically handling this inside the Java code (as you would handle
59 // ModuleLayer::EMPTY_LAYER, for example).
60 //
61 // Instead, we archive all static field of such Enum classes. At runtime,
62 // HeapShared::initialize_enum_klass() skips the <clinit> method and instead pulls
63 // the static fields out of the archived heap.
64 void CDSEnumKlass::handle_enum_obj(int level,
65 KlassSubGraphInfo* subgraph_info,
66 oop orig_obj) {
67 assert(level > 1, "must never be called at the first (outermost) level");
68 assert(is_enum_obj(orig_obj), "must be");
69
70 InstanceKlass* ik = InstanceKlass::cast(orig_obj->klass());
71 if (ik->has_archived_enum_objs()) {
72 return;
73 }
74
75 ik->set_has_archived_enum_objs();
76 ArchiveBuilder::get_buffered_klass(ik)->set_has_archived_enum_objs();
77
78 oop mirror = ik->java_mirror();
79 for (JavaFieldStream fs(ik); !fs.done(); fs.next()) {
80 if (fs.access_flags().is_static()) {
81 fieldDescriptor& fd = fs.field_descriptor();
82 if (fd.field_type() == T_OBJECT || fd.field_type() == T_ARRAY) {
83 archive_static_oop_field(level, subgraph_info, ik, mirror, fd);
84 } else {
85 archive_static_primitive_field(level, subgraph_info, ik, mirror, fd);
86 }
87 }
88 }
89 }
90
91 bool CDSEnumKlass::can_archive_static_oop_field(InstanceKlass* enum_klass, oop obj) {
92 Klass* klass = obj->klass();
93 return klass == enum_klass
94 || klass == enum_klass->array_klass_or_null()
95 || klass == vmClasses::Double_klass()
96 || klass == vmClasses::Float_klass();
97 }
98
99 void CDSEnumKlass::archive_static_oop_field(int level, KlassSubGraphInfo* subgraph_info,
100 InstanceKlass* ik, oop mirror, fieldDescriptor& fd) {
101 ResourceMark rm;
102 oop oop_field = mirror->obj_field(fd.offset());
103 if (oop_field == nullptr) {
104 return;
105 }
106
107 if (!can_archive_static_oop_field(ik, oop_field)) {
108 guarantee(false, "static field %s::%s is of the wrong type",
109 ik->external_name(), fd.name()->as_C_string());
110 }
111 bool success = HeapShared::archive_reachable_objects_from(level, subgraph_info, oop_field);
112 assert(success, "VM should have exited with unarchivable objects for _level > 1");
113 int root_index = HeapShared::append_root(oop_field);
114 log_info(cds, heap)("Archived enum obj @%d %s::%s (" INTPTR_FORMAT ")",
115 root_index, ik->external_name(), fd.name()->as_C_string(),
116 p2i((oopDesc*)oop_field));
117 SystemDictionaryShared::add_enum_klass_static_field(ik, root_index);
118 }
119
120
121 void CDSEnumKlass::archive_static_primitive_field(int level, KlassSubGraphInfo* subgraph_info,
122 InstanceKlass* ik, oop mirror, fieldDescriptor& fd) {
123 int v;
124 switch (fd.field_type()) {
125 case T_BOOLEAN:
126 v = mirror->bool_field(fd.offset());
127 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
128 break;
129 case T_BYTE:
130 v = mirror->byte_field(fd.offset());
131 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
132 break;
133 case T_SHORT:
134 v = mirror->short_field(fd.offset());
135 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
136 break;
137 case T_CHAR:
138 v = mirror->char_field(fd.offset());
139 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
140 break;
141 case T_INT:
142 v = mirror->int_field(fd.offset());
143 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
144 break;
145 case T_LONG:
146 {
147 jlong value = mirror->long_field(fd.offset());
148 v = value & 0xffffffff;
149 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
150 v = value > 32;
151 SystemDictionaryShared::add_enum_klass_static_field(ik, v);
152 }
153 break;
154 case T_FLOAT:
155 {
156 jfloat value = mirror->float_field(fd.offset());
157 int* p = (int*)(&value);
158 SystemDictionaryShared::add_enum_klass_static_field(ik, *p);
159 }
160 break;
161 case T_DOUBLE:
162 {
163 jdouble value = mirror->double_field(fd.offset());
164 int* p = (int*)(&value);
165 SystemDictionaryShared::add_enum_klass_static_field(ik, p[0]);
166 SystemDictionaryShared::add_enum_klass_static_field(ik, p[1]);
167 }
168 break;
169 default:
170 ShouldNotReachHere();
171 }
172 }
173
174
175 bool CDSEnumKlass::initialize_enum_klass(InstanceKlass* k, TRAPS) {
176 if (!ArchiveHeapLoader::is_in_use()) {
177 return false;
178 }
179
180 RunTimeClassInfo* info = RunTimeClassInfo::get_for(k);
181 assert(info != nullptr, "sanity");
182
183 if (log_is_enabled(Info, cds, heap)) {
184 ResourceMark rm;
185 log_info(cds, heap)("Initializing Enum class: %s", k->external_name());
186 }
187
188 oop mirror = k->java_mirror();
189 int i = 0;
190 for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
191 if (fs.access_flags().is_static()) {
192 int v = info->enum_klass_static_field_root_index_at(i++);
193 fieldDescriptor& fd = fs.field_descriptor();
194 switch (fd.field_type()) {
195 case T_OBJECT:
196 case T_ARRAY:
197 mirror->obj_field_put(fd.offset(), HeapShared::get_root(v, /*clear=*/true));
198 break;
199 case T_BOOLEAN:
200 mirror->bool_field_put(fd.offset(), v ? true : false);
201 break;
202 case T_BYTE:
203 mirror->byte_field_put(fd.offset(), (jbyte)v);
204 break;
205 case T_SHORT:
206 mirror->short_field_put(fd.offset(), (jshort)v);
207 break;
208 case T_CHAR:
209 mirror->char_field_put(fd.offset(), (jchar)v);
210 break;
211 case T_INT:
212 mirror->int_field_put(fd.offset(), v);
213 break;
214 case T_LONG:
215 {
216 int v2 = info->enum_klass_static_field_root_index_at(i++);
217 jlong lv = v2;
218 lv <<= 32;
219 lv += v;
220 mirror->long_field_put(fd.offset(), lv);
221 }
222 break;
223 case T_FLOAT:
224 {
225 jfloat* p = (float*)&v;
226 mirror->float_field_put(fd.offset(), *p);
227 }
228 break;
229 case T_DOUBLE:
230 {
231 int v2 = info->enum_klass_static_field_root_index_at(i++);
232 jdouble d = 0;
233 int* p = (int*)(&d);
234 p[0] = v;
235 p[1] = v2;
236 mirror->double_field_put(fd.offset(), d);
237 }
238 break;
239 default:
240 ShouldNotReachHere();
241 }
242 }
243 }
244 return true;
245 }
246 #endif