Tue, 08 Aug 2017 15:57:29 +0800
merge
1 /*
2 * Copyright (c) 2003, 2013, 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 /*
26 * This file has been modified by Loongson Technology in 2015. These
27 * modifications are Copyright (c) 2015 Loongson Technology, and are made
28 * available on the same license terms set forth above.
29 */
31 #ifndef SHARE_VM_PRIMS_JVMTIREDEFINECLASSES_HPP
32 #define SHARE_VM_PRIMS_JVMTIREDEFINECLASSES_HPP
34 #include "jvmtifiles/jvmtiEnv.hpp"
35 #include "memory/oopFactory.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "oops/objArrayKlass.hpp"
38 #include "oops/objArrayOop.hpp"
39 #include "prims/jvmtiRedefineClassesTrace.hpp"
40 #include "runtime/vm_operations.hpp"
41 #include "prims/jvmtiThreadState.hpp"
43 // Introduction:
44 //
45 // The RedefineClasses() API is used to change the definition of one or
46 // more classes. While the API supports redefining more than one class
47 // in a single call, in general, the API is discussed in the context of
48 // changing the definition of a single current class to a single new
49 // class. For clarity, the current class is will always be called
50 // "the_class" and the new class will always be called "scratch_class".
51 //
52 // The name "the_class" is used because there is only one structure
53 // that represents a specific class; redefinition does not replace the
54 // structure, but instead replaces parts of the structure. The name
55 // "scratch_class" is used because the structure that represents the
56 // new definition of a specific class is simply used to carry around
57 // the parts of the new definition until they are used to replace the
58 // appropriate parts in the_class. Once redefinition of a class is
59 // complete, scratch_class is thrown away.
60 //
61 //
62 // Implementation Overview:
63 //
64 // The RedefineClasses() API is mostly a wrapper around the VM op that
65 // does the real work. The work is split in varying degrees between
66 // doit_prologue(), doit() and doit_epilogue().
67 //
68 // 1) doit_prologue() is called by the JavaThread on the way to a
69 // safepoint. It does parameter verification and loads scratch_class
70 // which involves:
71 // - parsing the incoming class definition using the_class' class
72 // loader and security context
73 // - linking scratch_class
74 // - merging constant pools and rewriting bytecodes as needed
75 // for the merged constant pool
76 // - verifying the bytecodes in scratch_class
77 // - setting up the constant pool cache and rewriting bytecodes
78 // as needed to use the cache
79 // - finally, scratch_class is compared to the_class to verify
80 // that it is a valid replacement class
81 // - if everything is good, then scratch_class is saved in an
82 // instance field in the VM operation for the doit() call
83 //
84 // Note: A JavaThread must do the above work.
85 //
86 // 2) doit() is called by the VMThread during a safepoint. It installs
87 // the new class definition(s) which involves:
88 // - retrieving the scratch_class from the instance field in the
89 // VM operation
90 // - house keeping (flushing breakpoints and caches, deoptimizing
91 // dependent compiled code)
92 // - replacing parts in the_class with parts from scratch_class
93 // - adding weak reference(s) to track the obsolete but interesting
94 // parts of the_class
95 // - adjusting constant pool caches and vtables in other classes
96 // that refer to methods in the_class. These adjustments use the
97 // ClassLoaderDataGraph::classes_do() facility which only allows
98 // a helper method to be specified. The interesting parameters
99 // that we would like to pass to the helper method are saved in
100 // static global fields in the VM operation.
101 // - telling the SystemDictionary to notice our changes
102 //
103 // Note: the above work must be done by the VMThread to be safe.
104 //
105 // 3) doit_epilogue() is called by the JavaThread after the VM op
106 // is finished and the safepoint is done. It simply cleans up
107 // memory allocated in doit_prologue() and used in doit().
108 //
109 //
110 // Constant Pool Details:
111 //
112 // When the_class is redefined, we cannot just replace the constant
113 // pool in the_class with the constant pool from scratch_class because
114 // that could confuse obsolete methods that may still be running.
115 // Instead, the constant pool from the_class, old_cp, is merged with
116 // the constant pool from scratch_class, scratch_cp. The resulting
117 // constant pool, merge_cp, replaces old_cp in the_class.
118 //
119 // The key part of any merging algorithm is the entry comparison
120 // function so we have to know the types of entries in a constant pool
121 // in order to merge two of them together. Constant pools can contain
122 // up to 12 different kinds of entries; the JVM_CONSTANT_Unicode entry
123 // is not presently used so we only have to worry about the other 11
124 // entry types. For the purposes of constant pool merging, it is
125 // helpful to know that the 11 entry types fall into 3 different
126 // subtypes: "direct", "indirect" and "double-indirect".
127 //
128 // Direct CP entries contain data and do not contain references to
129 // other CP entries. The following are direct CP entries:
130 // JVM_CONSTANT_{Double,Float,Integer,Long,Utf8}
131 //
132 // Indirect CP entries contain 1 or 2 references to a direct CP entry
133 // and no other data. The following are indirect CP entries:
134 // JVM_CONSTANT_{Class,NameAndType,String}
135 //
136 // Double-indirect CP entries contain two references to indirect CP
137 // entries and no other data. The following are double-indirect CP
138 // entries:
139 // JVM_CONSTANT_{Fieldref,InterfaceMethodref,Methodref}
140 //
141 // When comparing entries between two constant pools, the entry types
142 // are compared first and if they match, then further comparisons are
143 // made depending on the entry subtype. Comparing direct CP entries is
144 // simply a matter of comparing the data associated with each entry.
145 // Comparing both indirect and double-indirect CP entries requires
146 // recursion.
147 //
148 // Fortunately, the recursive combinations are limited because indirect
149 // CP entries can only refer to direct CP entries and double-indirect
150 // CP entries can only refer to indirect CP entries. The following is
151 // an example illustration of the deepest set of indirections needed to
152 // access the data associated with a JVM_CONSTANT_Fieldref entry:
153 //
154 // JVM_CONSTANT_Fieldref {
155 // class_index => JVM_CONSTANT_Class {
156 // name_index => JVM_CONSTANT_Utf8 {
157 // <data-1>
158 // }
159 // }
160 // name_and_type_index => JVM_CONSTANT_NameAndType {
161 // name_index => JVM_CONSTANT_Utf8 {
162 // <data-2>
163 // }
164 // descriptor_index => JVM_CONSTANT_Utf8 {
165 // <data-3>
166 // }
167 // }
168 // }
169 //
170 // The above illustration is not a data structure definition for any
171 // computer language. The curly braces ('{' and '}') are meant to
172 // delimit the context of the "fields" in the CP entry types shown.
173 // Each indirection from the JVM_CONSTANT_Fieldref entry is shown via
174 // "=>", e.g., the class_index is used to indirectly reference a
175 // JVM_CONSTANT_Class entry where the name_index is used to indirectly
176 // reference a JVM_CONSTANT_Utf8 entry which contains the interesting
177 // <data-1>. In order to understand a JVM_CONSTANT_Fieldref entry, we
178 // have to do a total of 5 indirections just to get to the CP entries
179 // that contain the interesting pieces of data and then we have to
180 // fetch the three pieces of data. This means we have to do a total of
181 // (5 + 3) * 2 == 16 dereferences to compare two JVM_CONSTANT_Fieldref
182 // entries.
183 //
184 // Here is the indirection, data and dereference count for each entry
185 // type:
186 //
187 // JVM_CONSTANT_Class 1 indir, 1 data, 2 derefs
188 // JVM_CONSTANT_Double 0 indir, 1 data, 1 deref
189 // JVM_CONSTANT_Fieldref 2 indir, 3 data, 8 derefs
190 // JVM_CONSTANT_Float 0 indir, 1 data, 1 deref
191 // JVM_CONSTANT_Integer 0 indir, 1 data, 1 deref
192 // JVM_CONSTANT_InterfaceMethodref 2 indir, 3 data, 8 derefs
193 // JVM_CONSTANT_Long 0 indir, 1 data, 1 deref
194 // JVM_CONSTANT_Methodref 2 indir, 3 data, 8 derefs
195 // JVM_CONSTANT_NameAndType 1 indir, 2 data, 4 derefs
196 // JVM_CONSTANT_String 1 indir, 1 data, 2 derefs
197 // JVM_CONSTANT_Utf8 0 indir, 1 data, 1 deref
198 //
199 // So different subtypes of CP entries require different amounts of
200 // work for a proper comparison.
201 //
202 // Now that we've talked about the different entry types and how to
203 // compare them we need to get back to merging. This is not a merge in
204 // the "sort -u" sense or even in the "sort" sense. When we merge two
205 // constant pools, we copy all the entries from old_cp to merge_cp,
206 // preserving entry order. Next we append all the unique entries from
207 // scratch_cp to merge_cp and we track the index changes from the
208 // location in scratch_cp to the possibly new location in merge_cp.
209 // When we are done, any obsolete code that is still running that
210 // uses old_cp should not be able to observe any difference if it
211 // were to use merge_cp. As for the new code in scratch_class, it is
212 // modified to use the appropriate index values in merge_cp before it
213 // is used to replace the code in the_class.
214 //
215 // There is one small complication in copying the entries from old_cp
216 // to merge_cp. Two of the CP entry types are special in that they are
217 // lazily resolved. Before explaining the copying complication, we need
218 // to digress into CP entry resolution.
219 //
220 // JVM_CONSTANT_Class entries are present in the class file, but are not
221 // stored in memory as such until they are resolved. The entries are not
222 // resolved unless they are used because resolution is expensive. During class
223 // file parsing the entries are initially stored in memory as
224 // JVM_CONSTANT_ClassIndex and JVM_CONSTANT_StringIndex entries. These special
225 // CP entry types indicate that the JVM_CONSTANT_Class and JVM_CONSTANT_String
226 // entries have been parsed, but the index values in the entries have not been
227 // validated. After the entire constant pool has been parsed, the index
228 // values can be validated and then the entries are converted into
229 // JVM_CONSTANT_UnresolvedClass and JVM_CONSTANT_String
230 // entries. During this conversion process, the UTF8 values that are
231 // indirectly referenced by the JVM_CONSTANT_ClassIndex and
232 // JVM_CONSTANT_StringIndex entries are changed into Symbol*s and the
233 // entries are modified to refer to the Symbol*s. This optimization
234 // eliminates one level of indirection for those two CP entry types and
235 // gets the entries ready for verification. Verification expects to
236 // find JVM_CONSTANT_UnresolvedClass but not JVM_CONSTANT_Class entries.
237 //
238 // Now we can get back to the copying complication. When we copy
239 // entries from old_cp to merge_cp, we have to revert any
240 // JVM_CONSTANT_Class entries to JVM_CONSTANT_UnresolvedClass entries
241 // or verification will fail.
242 //
243 // It is important to explicitly state that the merging algorithm
244 // effectively unresolves JVM_CONSTANT_Class entries that were in the
245 // old_cp when they are changed into JVM_CONSTANT_UnresolvedClass
246 // entries in the merge_cp. This is done both to make verification
247 // happy and to avoid adding more brittleness between RedefineClasses
248 // and the constant pool cache. By allowing the constant pool cache
249 // implementation to (re)resolve JVM_CONSTANT_UnresolvedClass entries
250 // into JVM_CONSTANT_Class entries, we avoid having to embed knowledge
251 // about those algorithms in RedefineClasses.
252 //
253 // Appending unique entries from scratch_cp to merge_cp is straight
254 // forward for direct CP entries and most indirect CP entries. For the
255 // indirect CP entry type JVM_CONSTANT_NameAndType and for the double-
256 // indirect CP entry types, the presence of more than one piece of
257 // interesting data makes appending the entries more complicated.
258 //
259 // For the JVM_CONSTANT_{Double,Float,Integer,Long,Utf8} entry types,
260 // the entry is simply copied from scratch_cp to the end of merge_cp.
261 // If the index in scratch_cp is different than the destination index
262 // in merge_cp, then the change in index value is tracked.
263 //
264 // Note: the above discussion for the direct CP entries also applies
265 // to the JVM_CONSTANT_UnresolvedClass entry types.
266 //
267 // For the JVM_CONSTANT_Class entry types, since there is only
268 // one data element at the end of the recursion, we know that we have
269 // either one or two unique entries. If the JVM_CONSTANT_Utf8 entry is
270 // unique then it is appended to merge_cp before the current entry.
271 // If the JVM_CONSTANT_Utf8 entry is not unique, then the current entry
272 // is updated to refer to the duplicate entry in merge_cp before it is
273 // appended to merge_cp. Again, any changes in index values are tracked
274 // as needed.
275 //
276 // Note: the above discussion for JVM_CONSTANT_Class entry
277 // types is theoretical. Since those entry types have already been
278 // optimized into JVM_CONSTANT_UnresolvedClass entry types,
279 // they are handled as direct CP entries.
280 //
281 // For the JVM_CONSTANT_NameAndType entry type, since there are two
282 // data elements at the end of the recursions, we know that we have
283 // between one and three unique entries. Any unique JVM_CONSTANT_Utf8
284 // entries are appended to merge_cp before the current entry. For any
285 // JVM_CONSTANT_Utf8 entries that are not unique, the current entry is
286 // updated to refer to the duplicate entry in merge_cp before it is
287 // appended to merge_cp. Again, any changes in index values are tracked
288 // as needed.
289 //
290 // For the JVM_CONSTANT_{Fieldref,InterfaceMethodref,Methodref} entry
291 // types, since there are two indirect CP entries and three data
292 // elements at the end of the recursions, we know that we have between
293 // one and six unique entries. See the JVM_CONSTANT_Fieldref diagram
294 // above for an example of all six entries. The uniqueness algorithm
295 // for the JVM_CONSTANT_Class and JVM_CONSTANT_NameAndType entries is
296 // covered above. Any unique entries are appended to merge_cp before
297 // the current entry. For any entries that are not unique, the current
298 // entry is updated to refer to the duplicate entry in merge_cp before
299 // it is appended to merge_cp. Again, any changes in index values are
300 // tracked as needed.
301 //
302 //
303 // Other Details:
304 //
305 // Details for other parts of RedefineClasses need to be written.
306 // This is a placeholder section.
307 //
308 //
309 // Open Issues (in no particular order):
310 //
311 // - How do we serialize the RedefineClasses() API without deadlocking?
312 //
313 // - SystemDictionary::parse_stream() was called with a NULL protection
314 // domain since the initial version. This has been changed to pass
315 // the_class->protection_domain(). This change has been tested with
316 // all NSK tests and nothing broke, but what will adding it now break
317 // in ways that we don't test?
318 //
319 // - GenerateOopMap::rewrite_load_or_store() has a comment in its
320 // (indirect) use of the Relocator class that the max instruction
321 // size is 4 bytes. goto_w and jsr_w are 5 bytes and wide/iinc is
322 // 6 bytes. Perhaps Relocator only needs a 4 byte buffer to do
323 // what it does to the bytecodes. More investigation is needed.
324 //
325 // - How do we know if redefine_single_class() and the guts of
326 // InstanceKlass are out of sync? I don't think this can be
327 // automated, but we should probably order the work in
328 // redefine_single_class() to match the order of field
329 // definitions in InstanceKlass. We also need to add some
330 // comments about keeping things in sync.
331 //
332 // - set_new_constant_pool() is huge and we should consider refactoring
333 // it into smaller chunks of work.
334 //
335 // - The exception table update code in set_new_constant_pool() defines
336 // const values that are also defined in a local context elsewhere.
337 // The same literal values are also used in elsewhere. We need to
338 // coordinate a cleanup of these constants with Runtime.
339 //
341 struct JvmtiCachedClassFileData {
342 jint length;
343 unsigned char data[1];
344 };
346 class VM_RedefineClasses: public VM_Operation {
347 private:
348 // These static fields are needed by ClassLoaderDataGraph::classes_do()
349 // facility and the AdjustCpoolCacheAndVtable helper:
350 static Array<Method*>* _old_methods;
351 static Array<Method*>* _new_methods;
352 static Method** _matching_old_methods;
353 static Method** _matching_new_methods;
354 static Method** _deleted_methods;
355 static Method** _added_methods;
356 static int _matching_methods_length;
357 static int _deleted_methods_length;
358 static int _added_methods_length;
359 static Klass* _the_class_oop;
361 // The instance fields are used to pass information from
362 // doit_prologue() to doit() and doit_epilogue().
363 jint _class_count;
364 const jvmtiClassDefinition *_class_defs; // ptr to _class_count defs
366 // This operation is used by both RedefineClasses and
367 // RetransformClasses. Indicate which.
368 JvmtiClassLoadKind _class_load_kind;
370 // _index_map_count is just an optimization for knowing if
371 // _index_map_p contains any entries.
372 int _index_map_count;
373 intArray * _index_map_p;
375 // _operands_index_map_count is just an optimization for knowing if
376 // _operands_index_map_p contains any entries.
377 int _operands_cur_length;
378 int _operands_index_map_count;
379 intArray * _operands_index_map_p;
381 // ptr to _class_count scratch_classes
382 Klass** _scratch_classes;
383 jvmtiError _res;
385 // Performance measurement support. These timers do not cover all
386 // the work done for JVM/TI RedefineClasses() but they do cover
387 // the heavy lifting.
388 elapsedTimer _timer_rsc_phase1;
389 elapsedTimer _timer_rsc_phase2;
390 elapsedTimer _timer_vm_op_prologue;
392 // These routines are roughly in call order unless otherwise noted.
394 // Load the caller's new class definition(s) into _scratch_classes.
395 // Constant pool merging work is done here as needed. Also calls
396 // compare_and_normalize_class_versions() to verify the class
397 // definition(s).
398 jvmtiError load_new_class_versions(TRAPS);
400 // Verify that the caller provided class definition(s) that meet
401 // the restrictions of RedefineClasses. Normalize the order of
402 // overloaded methods as needed.
403 jvmtiError compare_and_normalize_class_versions(
404 instanceKlassHandle the_class, instanceKlassHandle scratch_class);
406 // Figure out which new methods match old methods in name and signature,
407 // which methods have been added, and which are no longer present
408 void compute_added_deleted_matching_methods();
410 // Change jmethodIDs to point to the new methods
411 void update_jmethod_ids();
413 // In addition to marking methods as obsolete, this routine
414 // records which methods are EMCP (Equivalent Module Constant
415 // Pool) in the emcp_methods BitMap and returns the number of
416 // EMCP methods via emcp_method_count_p. This information is
417 // used when information about the previous version of the_class
418 // is squirreled away.
419 void check_methods_and_mark_as_obsolete(BitMap *emcp_methods,
420 int * emcp_method_count_p);
421 void transfer_old_native_function_registrations(instanceKlassHandle the_class);
423 // Install the redefinition of a class
424 void redefine_single_class(jclass the_jclass,
425 Klass* scratch_class_oop, TRAPS);
427 void swap_annotations(instanceKlassHandle new_class,
428 instanceKlassHandle scratch_class);
430 // Increment the classRedefinedCount field in the specific InstanceKlass
431 // and in all direct and indirect subclasses.
432 void increment_class_counter(InstanceKlass *ik, TRAPS);
434 // Support for constant pool merging (these routines are in alpha order):
435 void append_entry(constantPoolHandle scratch_cp, int scratch_i,
436 constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS);
437 void append_operand(constantPoolHandle scratch_cp, int scratch_bootstrap_spec_index,
438 constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS);
439 void finalize_operands_merge(constantPoolHandle merge_cp, TRAPS);
440 int find_or_append_indirect_entry(constantPoolHandle scratch_cp, int scratch_i,
441 constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS);
442 int find_or_append_operand(constantPoolHandle scratch_cp, int scratch_bootstrap_spec_index,
443 constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS);
444 int find_new_index(int old_index);
445 int find_new_operand_index(int old_bootstrap_spec_index);
446 bool is_unresolved_class_mismatch(constantPoolHandle cp1, int index1,
447 constantPoolHandle cp2, int index2);
448 void map_index(constantPoolHandle scratch_cp, int old_index, int new_index);
449 void map_operand_index(int old_bootstrap_spec_index, int new_bootstrap_spec_index);
450 bool merge_constant_pools(constantPoolHandle old_cp,
451 constantPoolHandle scratch_cp, constantPoolHandle *merge_cp_p,
452 int *merge_cp_length_p, TRAPS);
453 jvmtiError merge_cp_and_rewrite(instanceKlassHandle the_class,
454 instanceKlassHandle scratch_class, TRAPS);
455 u2 rewrite_cp_ref_in_annotation_data(
456 AnnotationArray* annotations_typeArray, int &byte_i_ref,
457 const char * trace_mesg, TRAPS);
458 bool rewrite_cp_refs(instanceKlassHandle scratch_class, TRAPS);
459 bool rewrite_cp_refs_in_annotation_struct(
460 AnnotationArray* class_annotations, int &byte_i_ref, TRAPS);
461 bool rewrite_cp_refs_in_annotations_typeArray(
462 AnnotationArray* annotations_typeArray, int &byte_i_ref, TRAPS);
463 bool rewrite_cp_refs_in_class_annotations(
464 instanceKlassHandle scratch_class, TRAPS);
465 bool rewrite_cp_refs_in_element_value(
466 AnnotationArray* class_annotations, int &byte_i_ref, TRAPS);
467 bool rewrite_cp_refs_in_fields_annotations(
468 instanceKlassHandle scratch_class, TRAPS);
469 void rewrite_cp_refs_in_method(methodHandle method,
470 methodHandle * new_method_p, TRAPS);
471 bool rewrite_cp_refs_in_methods(instanceKlassHandle scratch_class, TRAPS);
472 bool rewrite_cp_refs_in_methods_annotations(
473 instanceKlassHandle scratch_class, TRAPS);
474 bool rewrite_cp_refs_in_methods_default_annotations(
475 instanceKlassHandle scratch_class, TRAPS);
476 bool rewrite_cp_refs_in_methods_parameter_annotations(
477 instanceKlassHandle scratch_class, TRAPS);
478 void rewrite_cp_refs_in_stack_map_table(methodHandle method, TRAPS);
479 void rewrite_cp_refs_in_verification_type_info(
480 address& stackmap_addr_ref, address stackmap_end, u2 frame_i,
481 u1 frame_size, TRAPS);
482 void set_new_constant_pool(ClassLoaderData* loader_data,
483 instanceKlassHandle scratch_class,
484 constantPoolHandle scratch_cp, int scratch_cp_length, TRAPS);
486 void flush_dependent_code(instanceKlassHandle k_h, TRAPS);
488 static void dump_methods();
490 // Check that there are no old or obsolete methods
491 class CheckClass : public KlassClosure {
492 Thread* _thread;
493 public:
494 CheckClass(Thread* t) : _thread(t) {}
495 void do_klass(Klass* k);
496 };
498 // Unevolving classes may point to methods of the_class directly
499 // from their constant pool caches, itables, and/or vtables. We
500 // use the ClassLoaderDataGraph::classes_do() facility and this helper
501 // to fix up these pointers.
502 class AdjustCpoolCacheAndVtable : public KlassClosure {
503 Thread* _thread;
504 public:
505 AdjustCpoolCacheAndVtable(Thread* t) : _thread(t) {}
506 void do_klass(Klass* k);
507 };
509 public:
510 VM_RedefineClasses(jint class_count,
511 const jvmtiClassDefinition *class_defs,
512 JvmtiClassLoadKind class_load_kind);
513 VMOp_Type type() const { return VMOp_RedefineClasses; }
514 bool doit_prologue();
515 void doit();
516 void doit_epilogue();
518 bool allow_nested_vm_operations() const { return true; }
519 jvmtiError check_error() { return _res; }
521 // Modifiable test must be shared between IsModifiableClass query
522 // and redefine implementation
523 static bool is_modifiable_class(oop klass_mirror);
525 static jint get_cached_class_file_len(JvmtiCachedClassFileData *cache) {
526 return cache == NULL ? 0 : cache->length;
527 }
528 static unsigned char * get_cached_class_file_bytes(JvmtiCachedClassFileData *cache) {
529 return cache == NULL ? NULL : cache->data;
530 }
531 };
532 #endif // SHARE_VM_PRIMS_JVMTIREDEFINECLASSES_HPP