1 /*
2 * Copyright (c) 2016, 2019, 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 "jvm.h"
27 #include "classfile/classFileParser.hpp"
28 #include "classfile/classFileStream.hpp"
29 #include "classfile/javaClasses.hpp"
30 #include "classfile/stackMapTable.hpp"
31 #include "classfile/verificationType.hpp"
32 #include "interpreter/bytecodes.hpp"
33 #include "jfr/instrumentation/jfrEventClassTransformer.hpp"
34 #include "jfr/jni/jfrJavaSupport.hpp"
35 #include "jfr/jni/jfrUpcalls.hpp"
36 #include "jfr/recorder/access/jfrEventClass.hpp"
37 #include "jfr/recorder/jfrRecorder.hpp"
38 #include "jfr/utilities/jfrBigEndian.hpp"
39 #include "jfr/writers/jfrBigEndianWriter.hpp"
40 #include "jfr/utilities/jfrLog.hpp"
41 #include "memory/allocation.inline.hpp"
42 #include "memory/resourceArea.hpp"
43
44 #include "oops/instanceKlass.hpp"
45 #include "oops/method.hpp"
46 #include "prims/jvmtiRedefineClasses.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "runtime/os.hpp"
49 #include "runtime/thread.inline.hpp"
50 #include "utilities/exceptions.hpp"
51 #include "utilities/globalDefinitions.hpp"
52 #include "utilities/macros.hpp"
53
54 static const u2 number_of_new_methods = 5;
55 static const u2 number_of_new_fields = 3;
56 static const int extra_stream_bytes = 0x280;
57 static const u2 invalid_cp_index = 0;
58
59 static const char* utf8_constants[] = {
60 "Code", // 0
61 "J", // 1
62 "commit", // 2
63 "eventHandler", // 3
64 "Ljdk/jfr/internal/handlers/EventHandler;", // 4
65 "duration", // 5
66 "begin", // 6
67 "()V", // 7
68 "isEnabled", // 8
69 "()Z", // 9
70 "end", // 10
71 "shouldCommit", // 11
72 "startTime", // 12
73 "<clinit>", // 13
74 "jdk/jfr/FlightRecorder", // 14
75 "register", // 15
76 "(Ljava/lang/Class;)V", // 16 // LAST_REQUIRED_UTF8
77 "StackMapTable", // 17
78 "Exceptions", // 18
79 "LineNumberTable", // 20
80 "LocalVariableTable", // 21
81 "LocalVariableTypeTable", // 22
82 "RuntimeVisibleAnnotation" // 23
83 };
84
85 enum utf8_req_symbols {
86 UTF8_REQ_Code,
87 UTF8_REQ_J_FIELD_DESC,
88 UTF8_REQ_commit,
89 UTF8_REQ_eventHandler,
90 UTF8_REQ_eventHandler_FIELD_DESC,
91 UTF8_REQ_duration,
92 UTF8_REQ_begin,
93 UTF8_REQ_EMPTY_VOID_METHOD_DESC,
94 UTF8_REQ_isEnabled,
95 UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC,
96 UTF8_REQ_end,
97 UTF8_REQ_shouldCommit,
98 UTF8_REQ_startTime,
99 UTF8_REQ_clinit,
100 UTF8_REQ_FlightRecorder,
101 UTF8_REQ_register,
102 UTF8_REQ_CLASS_VOID_METHOD_DESC,
103 NOF_UTF8_REQ_SYMBOLS
104 };
105
106 enum utf8_opt_symbols {
107 UTF8_OPT_StackMapTable = NOF_UTF8_REQ_SYMBOLS,
108 UTF8_OPT_Exceptions,
109 UTF8_OPT_LineNumberTable,
110 UTF8_OPT_LocalVariableTable,
111 UTF8_OPT_LocalVariableTypeTable,
112 UTF8_OPT_RuntimeVisibleAnnotation,
113 NOF_UTF8_SYMBOLS
114 };
115
116 static u1 empty_void_method_code_attribute[] = {
117 0x0,
118 0x0,
119 0x0,
120 0xd, // attribute len
121 0x0,
122 0x0, // max stack
123 0x0,
124 0x1, // max locals
125 0x0,
126 0x0,
127 0x0,
128 0x1, // code length
129 Bytecodes::_return,
130 0x0,
131 0x0, // ex table len
132 0x0,
133 0x0 // attributes_count
134 };
135
136 static u1 boolean_method_code_attribute[] = {
137 0x0,
138 0x0,
139 0x0,
140 0xe,
141 0x0,
142 0x1, // max stack
143 0x0,
144 0x1, // max locals
145 0x0,
146 0x0,
147 0x0,
148 0x2,
149 Bytecodes::_iconst_0,
150 Bytecodes::_ireturn,
151 0x0,
152 0x0, // ex table len
153 0x0,
154 0x0, // attributes_count
155 };
156
157 // annotation processing support
158
159 enum { // initial annotation layout
160 atype_off = 0, // utf8 such as 'Ljava/lang/annotation/Retention;'
161 count_off = 2, // u2 such as 1 (one value)
162 member_off = 4, // utf8 such as 'value'
163 tag_off = 6, // u1 such as 'c' (type) or 'e' (enum)
164 e_tag_val = 'e',
165 e_type_off = 7, // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;'
166 e_con_off = 9, // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME'
167 e_size = 11, // end of 'e' annotation
168 c_tag_val = 'c', // payload is type
169 c_con_off = 7, // utf8 payload, such as 'I'
170 c_size = 9, // end of 'c' annotation
171 s_tag_val = 's', // payload is String
172 s_con_off = 7, // utf8 payload, such as 'Ljava/lang/String;'
173 s_size = 9,
174 min_size = 6 // smallest possible size (zero members)
175 };
176
177 static int skip_annotation_value(const address, int, int); // fwd decl
178
179 // Skip an annotation. Return >=limit if there is any problem.
180 static int next_annotation_index(const address buffer, int limit, int index) {
181 assert(buffer != NULL, "invariant");
182 index += 2; // skip atype
183 if ((index += 2) >= limit) {
184 return limit;
185 }
186 int nof_members = JfrBigEndian::read<u2>(buffer + index - 2);
187 while (--nof_members >= 0 && index < limit) {
188 index += 2; // skip member
189 index = skip_annotation_value(buffer, limit, index);
190 }
191 return index;
192 }
193
194 // Skip an annotation value. Return >=limit if there is any problem.
195 static int skip_annotation_value(const address buffer, int limit, int index) {
196 assert(buffer != NULL, "invariant");
197 // value := switch (tag:u1) {
198 // case B, C, I, S, Z, D, F, J, c: con:u2;
199 // case e: e_class:u2 e_name:u2;
200 // case s: s_con:u2;
201 // case [: do(nval:u2) {value};
202 // case @: annotation;
203 // case s: s_con:u2;
204 // }
205 if ((index += 1) >= limit) {
206 return limit;
207 }
208 const u1 tag = buffer[index - 1];
209 switch (tag) {
210 case 'B':
211 case 'C':
212 case 'I':
213 case 'S':
214 case 'Z':
215 case 'D':
216 case 'F':
217 case 'J':
218 case 'c':
219 case 's':
220 index += 2; // skip con or s_con
221 break;
222 case 'e':
223 index += 4; // skip e_class, e_name
224 break;
225 case '[':
226 {
227 if ((index += 2) >= limit) {
228 return limit;
229 }
230 int nof_values = JfrBigEndian::read<u2>(buffer + index - 2);
231 while (--nof_values >= 0 && index < limit) {
232 index = skip_annotation_value(buffer, limit, index);
233 }
234 }
235 break;
236 case '@':
237 index = next_annotation_index(buffer, limit, index);
238 break;
239 default:
240 return limit; // bad tag byte
241 }
242 return index;
243 }
244
245 static const u2 number_of_elements_offset = (u2)2;
246 static const u2 element_name_offset = (u2)(number_of_elements_offset + 2);
247 static const u2 element_name_size = (u2)2;
248 static const u2 value_type_relative_offset = (u2)2;
249 static const u2 value_relative_offset = (u2)(value_type_relative_offset + 1);
250
251 // see JVMS - 4.7.16. The RuntimeVisibleAnnotations Attribute
252
253 class AnnotationElementIterator : public StackObj {
254 private:
255 const InstanceKlass* _ik;
256 const address _buffer;
257 const u2 _limit; // length of annotation
258 mutable u2 _current; // element
259 mutable u2 _next; // element
260 u2 value_index() const {
261 return JfrBigEndian::read<u2>(_buffer + _current + value_relative_offset);
262 }
263
264 public:
265 AnnotationElementIterator(const InstanceKlass* ik, address buffer, u2 limit) : _ik(ik),
266 _buffer(buffer),
267 _limit(limit),
268 _next(element_name_offset),
269 _current(element_name_offset) {
270 assert(_buffer != NULL, "invariant");
271 assert(_next == element_name_offset, "invariant");
272 assert(_current == element_name_offset, "invariant");
273 }
274
275 bool has_next() const {
276 return _next < _limit;
277 }
278
279 void move_to_next() const {
280 assert(has_next(), "invariant");
281 _current = _next;
282 if (_next < _limit) {
283 _next = skip_annotation_value(_buffer, _limit, _next + element_name_size);
284 }
285 assert(_next <= _limit, "invariant");
286 assert(_current <= _limit, "invariant");
287 }
288
289 u2 number_of_elements() const {
290 return JfrBigEndian::read<u2>(_buffer + number_of_elements_offset);
291 }
292
293 const Symbol* name() const {
294 assert(_current < _next, "invariant");
295 return _ik->constants()->symbol_at(JfrBigEndian::read<u2>(_buffer + _current));
296 }
297
298 char value_type() const {
299 return JfrBigEndian::read<u1>(_buffer + _current + value_type_relative_offset);
300 }
301
302 jint read_int() const {
303 return _ik->constants()->int_at(value_index());
304 }
305
306 bool read_bool() const {
307 return read_int() != 0;
308 }
309 };
310
311 class AnnotationIterator : public StackObj {
312 private:
313 const InstanceKlass* _ik;
314 // ensure _limit field is declared before _buffer
315 u2 _limit; // length of annotations array
316 const address _buffer;
317 mutable u2 _current; // annotation
318 mutable u2 _next; // annotation
319
320 public:
321 AnnotationIterator(const InstanceKlass* ik, AnnotationArray* ar) : _ik(ik),
322 _current(0),
323 _next(0),
324 _limit(ar != NULL ? ar->length() : 0),
325 _buffer(_limit > 2 ? ar->adr_at(2) : NULL) {
326 if (_buffer != NULL) {
327 _limit -= 2; // subtract sizeof(u2) number of annotations field
328 }
329 }
330 bool has_next() const {
331 return _next < _limit;
332 }
333
334 void move_to_next() const {
335 assert(has_next(), "invariant");
336 _current = _next;
337 if (_next < _limit) {
338 _next = next_annotation_index(_buffer, _limit, _next);
339 }
340 assert(_next <= _limit, "invariant");
341 assert(_current <= _limit, "invariant");
342 }
343 const AnnotationElementIterator elements() const {
344 assert(_current < _next, "invariant");
345 return AnnotationElementIterator(_ik, _buffer + _current, _next - _current);
346 }
347 const Symbol* type() const {
348 assert(_buffer != NULL, "invariant");
349 assert(_current < _limit, "invariant");
350 return _ik->constants()->symbol_at(JfrBigEndian::read<u2>(_buffer + _current));
351 }
352 };
353
354 static unsigned int unused_hash = 0;
355 static const char value_name[] = "value";
356 static bool has_registered_annotation(const InstanceKlass* ik, const Symbol* annotation_type, bool& value) {
357 assert(annotation_type != NULL, "invariant");
358 AnnotationArray* class_annotations = ik->class_annotations();
359 if (class_annotations == NULL) {
360 return false;
361 }
362
363 const AnnotationIterator annotation_iterator(ik, class_annotations);
364 while (annotation_iterator.has_next()) {
365 annotation_iterator.move_to_next();
366 if (annotation_iterator.type() == annotation_type) {
367 // target annotation found
368 static const Symbol* value_symbol =
369 SymbolTable::lookup_only(value_name, sizeof value_name - 1, unused_hash);
370 assert(value_symbol != NULL, "invariant");
371 const AnnotationElementIterator element_iterator = annotation_iterator.elements();
372 while (element_iterator.has_next()) {
373 element_iterator.move_to_next();
374 if (value_symbol == element_iterator.name()) {
375 // "value" element
376 assert('Z' == element_iterator.value_type(), "invariant");
377 value = element_iterator.read_bool();
378 return true;
379 }
380 }
381 }
382 }
383 return false;
384 }
385
386 static bool registered_annotation_value(const InstanceKlass* ik, const Symbol* const registered_symbol) {
387 assert(registered_symbol != NULL, "invariant");
388 assert(ik != NULL, "invariant");
389 assert(JdkJfrEvent::is_a(ik), "invariant");
390 bool registered_value = false;
391 if (has_registered_annotation(ik, registered_symbol, registered_value)) {
392 return registered_value;
393 }
394 InstanceKlass* super = InstanceKlass::cast(ik->super());
395 return registered_annotation_value(super, registered_symbol);
396 }
397
398 static const char registered_constant[] = "Ljdk/jfr/Registered;";
399
400 // Evaluate to the value of the first found "Ljdk/jfr/Registered;" annotation.
401 // Searching moves upwards in the klass hierarchy in order to support
402 // inherited annotations in addition to the ability to override.
403 static bool should_register_klass(const InstanceKlass* ik) {
404 static const Symbol* const registered_symbol = SymbolTable::lookup_only(registered_constant,
405 sizeof registered_constant - 1,
406 unused_hash);
407 assert(registered_symbol != NULL, "invariant");
408 return registered_annotation_value(ik, registered_symbol);
409 }
410 /*
411 * Map an utf8 constant back to its CONSTANT_UTF8_INFO
412 */
413 static u2 utf8_info_index(const InstanceKlass* ik, const Symbol* const target, TRAPS) {
414 assert(target != NULL, "invariant");
415 ConstantPool* cp = ik->constants();
416 const int cp_len = cp->length();
417 for (u2 index = 1; index < cp_len; ++index) {
418 const constantTag tag = cp->tag_at(index);
419 if (tag.is_utf8()) {
420 const Symbol* const utf8_sym = cp->symbol_at(index);
421 assert(utf8_sym != NULL, "invariant");
422 if (utf8_sym == target) {
423 return index;
424 }
425 }
426 }
427 // not in constant pool
428 return invalid_cp_index;
429 }
430
431 #ifdef ASSERT
432 static bool is_index_within_range(u2 index, u2 orig_cp_len, u2 new_cp_entries_len) {
433 return index > 0 && index < orig_cp_len + new_cp_entries_len;
434 }
435 #endif
436
437 static u2 add_utf8_info(JfrBigEndianWriter& writer, const char* utf8_constant, u2 orig_cp_len, u2& new_cp_entries_len) {
438 assert(utf8_constant != NULL, "invariant");
439 writer.write<u1>(JVM_CONSTANT_Utf8);
440 writer.write_utf8_u2_len(utf8_constant);
441 assert(writer.is_valid(), "invariant");
442 // return index for the added utf8 info
443 return orig_cp_len + new_cp_entries_len++;
444 }
445
446 static u2 add_method_ref_info(JfrBigEndianWriter& writer,
447 u2 cls_name_index,
448 u2 method_index,
449 u2 desc_index,
450 u2 orig_cp_len,
451 u2& number_of_new_constants,
452 TRAPS) {
453 assert(is_index_within_range(cls_name_index, orig_cp_len, number_of_new_constants), "invariant");
454 assert(is_index_within_range(method_index, orig_cp_len, number_of_new_constants), "invariant");
455 assert(is_index_within_range(desc_index, orig_cp_len, number_of_new_constants), "invariant");
456 writer.write<u1>(JVM_CONSTANT_Class);
457 writer.write<u2>(cls_name_index);
458 const u2 cls_entry_index = orig_cp_len + number_of_new_constants;
459 ++number_of_new_constants;
460 writer.write<u1>(JVM_CONSTANT_NameAndType);
461 writer.write<u2>(method_index);
462 writer.write<u2>(desc_index);
463 const u2 nat_entry_index = orig_cp_len + number_of_new_constants;
464 ++number_of_new_constants;
465 writer.write<u1>(JVM_CONSTANT_Methodref);
466 writer.write<u2>(cls_entry_index);
467 writer.write<u2>(nat_entry_index);
468 // post-increment number_of_new_constants
469 // value returned is the index to the added method_ref
470 return orig_cp_len + number_of_new_constants++;
471 }
472
473 static u2 add_flr_register_method_constants(JfrBigEndianWriter& writer,
474 const u2* utf8_indexes,
475 u2 orig_cp_len,
476 u2& number_of_new_constants,
477 TRAPS) {
478 assert(utf8_indexes != NULL, "invariant");
479 return add_method_ref_info(writer,
480 utf8_indexes[UTF8_REQ_FlightRecorder],
481 utf8_indexes[UTF8_REQ_register],
482 utf8_indexes[UTF8_REQ_CLASS_VOID_METHOD_DESC],
483 orig_cp_len,
484 number_of_new_constants,
485 THREAD);
486 }
487
488 /*
489 * field_info {
490 * u2 access_flags;
491 * u2 name_index;
492 * u2 descriptor_index;
493 * u2 attributes_count;
494 * attribute_info attributes[attributes_count];
495 * }
496 */
497 static jlong add_field_info(JfrBigEndianWriter& writer, u2 name_index, u2 desc_index, bool is_static = false) {
498 assert(name_index > 0, "invariant");
499 assert(desc_index > 0, "invariant");
500 DEBUG_ONLY(const jlong start_offset = writer.current_offset();)
501 writer.write<u2>(JVM_ACC_SYNTHETIC | JVM_ACC_PRIVATE | (is_static ? JVM_ACC_STATIC : JVM_ACC_TRANSIENT)); // flags
502 writer.write(name_index);
503 writer.write(desc_index);
504 writer.write((u2)0x0); // attributes_count
505 assert(writer.is_valid(), "invariant");
506 DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)
507 return writer.current_offset();
508 }
509
510 static u2 add_field_infos(JfrBigEndianWriter& writer, const u2* utf8_indexes) {
511 assert(utf8_indexes != NULL, "invariant");
512 add_field_info(writer,
513 utf8_indexes[UTF8_REQ_eventHandler],
514 utf8_indexes[UTF8_REQ_eventHandler_FIELD_DESC],
515 true); // static
516
517 add_field_info(writer,
518 utf8_indexes[UTF8_REQ_startTime],
519 utf8_indexes[UTF8_REQ_J_FIELD_DESC]);
520
521 add_field_info(writer,
522 utf8_indexes[UTF8_REQ_duration],
523 utf8_indexes[UTF8_REQ_J_FIELD_DESC]);
524
525 return number_of_new_fields;
526 }
527
528 /*
529 * method_info {
530 * u2 access_flags;
531 * u2 name_index;
532 * u2 descriptor_index;
533 * u2 attributes_count;
534 * attribute_info attributes[attributes_count];
535 * }
536 *
537 * Code_attribute {
538 * u2 attribute_name_index;
539 * u4 attribute_length;
540 * u2 max_stack;
541 * u2 max_locals;
542 * u4 code_length;
543 * u1 code[code_length];
544 * u2 exception_table_length;
545 * { u2 start_pc;
546 * u2 end_pc;
547 * u2 handler_pc;
548 * u2 catch_type;
549 * } exception_table[exception_table_length];
550 * u2 attributes_count;
551 * attribute_info attributes[attributes_count];
552 * }
553 */
554
555 static jlong add_method_info(JfrBigEndianWriter& writer,
556 u2 name_index,
557 u2 desc_index,
558 u2 code_index,
559 const u1* const code,
560 const size_t code_len) {
561 assert(name_index > 0, "invariant");
562 assert(desc_index > 0, "invariant");
563 assert(code_index > 0, "invariant");
564 DEBUG_ONLY(const jlong start_offset = writer.current_offset();)
565 writer.write<u2>(JVM_ACC_SYNTHETIC | JVM_ACC_PUBLIC); // flags
566 writer.write(name_index);
567 writer.write(desc_index);
568 writer.write<u2>(0x1); // attributes_count ; 1 for "Code" attribute
569 assert(writer.is_valid(), "invariant");
570 DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)
571 // Code attribute
572 writer.write(code_index); // "Code"
573 writer.bytes(code, code_len);
574 DEBUG_ONLY(assert((start_offset + 8 + 2 + (jlong)code_len) == writer.current_offset(), "invariant");)
575 return writer.current_offset();
576 }
577
578 /*
579 * On return, the passed stream will be positioned
580 * just after the constant pool section in the classfile
581 * and the cp length is returned.
582 *
583 * Stream should come in at the start position.
584 */
585 static u2 position_stream_after_cp(ClassFileStream* stream) {
586 assert(stream != NULL, "invariant");
587 assert(stream->current_offset() == 0, "invariant");
588 stream->skip_u4_fast(2); // 8 bytes skipped
589 const u2 cp_len = stream->get_u2_fast();
590 assert(cp_len > 0, "invariant");
591 // now spin the stream position to just after the constant pool
592 for (u2 index = 1; index < cp_len; ++index) {
593 const u1 tag = stream->get_u1_fast(); // cp tag
594 switch (tag) {
595 case JVM_CONSTANT_Class:
596 case JVM_CONSTANT_String: {
597 stream->skip_u2_fast(1); // skip 2 bytes
598 continue;
599 }
600 case JVM_CONSTANT_Fieldref:
601 case JVM_CONSTANT_Methodref:
602 case JVM_CONSTANT_InterfaceMethodref:
603 case JVM_CONSTANT_Integer:
604 case JVM_CONSTANT_Float:
605 case JVM_CONSTANT_NameAndType:
606 case JVM_CONSTANT_InvokeDynamic: {
607 stream->skip_u4_fast(1); // skip 4 bytes
608 continue;
609 }
610 case JVM_CONSTANT_Long:
611 case JVM_CONSTANT_Double: {
612 stream->skip_u4_fast(2); // skip 8 bytes
613 // Skip entry following eigth-byte constant, see JVM book p. 98
614 ++index;
615 continue;
616 }
617 case JVM_CONSTANT_Utf8: {
618 u2 utf8_length = stream->get_u2_fast();
619 stream->skip_u1_fast(utf8_length); // skip 2 + len bytes
620 continue;
621 }
622 case JVM_CONSTANT_MethodHandle:
623 case JVM_CONSTANT_MethodType: {
624 if (tag == JVM_CONSTANT_MethodHandle) {
625 stream->skip_u1_fast(1);
626 stream->skip_u2_fast(1); // skip 3 bytes
627 }
628 else if (tag == JVM_CONSTANT_MethodType) {
629 stream->skip_u2_fast(1); // skip 3 bytes
630 }
631 }
632 continue;
633 default:
634 assert(false, "error in skip logic!");
635 break;
636 } // end switch(tag)
637 }
638 return cp_len;
639 }
640
641 /*
642 * On return, the passed stream will be positioned
643 * just after the fields section in the classfile
644 * and the number of fields will be returned.
645 *
646 * Stream should come in positioned just before fields_count
647 */
648 static u2 position_stream_after_fields(ClassFileStream* stream) {
649 assert(stream != NULL, "invariant");
650 assert(stream->current_offset() > 0, "invariant");
651 // fields len
652 const u2 orig_fields_len = stream->get_u2_fast();
653 // fields
654 for (u2 i = 0; i < orig_fields_len; ++i) {
655 stream->skip_u2_fast(3);
656 const u2 attrib_info_len = stream->get_u2_fast();
657 for (u2 j = 0; j < attrib_info_len; ++j) {
658 stream->skip_u2_fast(1);
659 const u4 attrib_len = stream->get_u4_fast();
660 stream->skip_u1_fast(attrib_len);
661 }
662 }
663 return orig_fields_len;
664 }
665
666 /*
667 * On return, the passed stream will be positioned
668 * just after the methods section in the classfile
669 * and the number of methods will be returned.
670 *
671 * Stream should come in positioned just before methods_count
672 */
673 static u2 position_stream_after_methods(JfrBigEndianWriter& writer,
674 ClassFileStream* stream,
675 const u2* utf8_indexes,
676 bool register_klass,
677 const Method* clinit_method,
678 u4& orig_method_len_offset) {
679 assert(stream != NULL, "invariant");
680 assert(stream->current_offset() > 0, "invariant");
681 assert(utf8_indexes != NULL, "invariant");
682 // We will come back to this location when we
683 // know how many methods there will be.
684 writer.reserve(sizeof(u2));
685 const u2 orig_methods_len = stream->get_u2_fast();
686 // Move copy position past original method_count
687 // in order to not copy the original count
688 orig_method_len_offset += sizeof(u2);
689 for (u2 i = 0; i < orig_methods_len; ++i) {
690 const u4 method_offset = stream->current_offset();
691 stream->skip_u2_fast(1); // Access Flags
692 const u2 name_index = stream->get_u2_fast(); // Name index
693 stream->skip_u2_fast(1); // Descriptor index
694 const u2 attributes_count = stream->get_u2_fast();
695 for (u2 j = 0; j < attributes_count; ++j) {
696 stream->skip_u2_fast(1);
697 const u4 attrib_len = stream->get_u4_fast();
698 stream->skip_u1_fast(attrib_len);
699 }
700 if (clinit_method != NULL && name_index == clinit_method->name_index()) {
701 // The method just parsed is an existing <clinit> method.
702 // If the class has the @Registered(false) annotation, i.e. marking a class
703 // for opting out from automatic registration, then we do not need to do anything.
704 if (!register_klass) {
705 continue;
706 }
707 // Automatic registration with the jfr system is acccomplished
708 // by pre-pending code to the <clinit> method of the class.
709 // We will need to re-create a new <clinit> in a later step.
710 // For now, ensure that this method is excluded from the methods
711 // being copied.
712 writer.bytes(stream->buffer() + orig_method_len_offset,
713 method_offset - orig_method_len_offset);
714 assert(writer.is_valid(), "invariant");
715
716 // Update copy position to skip copy of <clinit> method
717 orig_method_len_offset = stream->current_offset();
718 }
719 }
720 return orig_methods_len;
721 }
722
723 static u2 add_method_infos(JfrBigEndianWriter& writer, const u2* utf8_indexes) {
724 assert(utf8_indexes != NULL, "invariant");
725 add_method_info(writer,
726 utf8_indexes[UTF8_REQ_begin],
727 utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],
728 utf8_indexes[UTF8_REQ_Code],
729 empty_void_method_code_attribute,
730 sizeof(empty_void_method_code_attribute));
731
732 assert(writer.is_valid(), "invariant");
733
734 add_method_info(writer,
735 utf8_indexes[UTF8_REQ_end],
736 utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],
737 utf8_indexes[UTF8_REQ_Code],
738 empty_void_method_code_attribute,
739 sizeof(empty_void_method_code_attribute));
740
741 assert(writer.is_valid(), "invariant");
742
743 add_method_info(writer,
744 utf8_indexes[UTF8_REQ_commit],
745 utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],
746 utf8_indexes[UTF8_REQ_Code],
747 empty_void_method_code_attribute,
748 sizeof(empty_void_method_code_attribute));
749
750 assert(writer.is_valid(), "invariant");
751
752 add_method_info(writer,
753 utf8_indexes[UTF8_REQ_isEnabled],
754 utf8_indexes[UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC],
755 utf8_indexes[UTF8_REQ_Code],
756 boolean_method_code_attribute,
757 sizeof(boolean_method_code_attribute));
758
759 assert(writer.is_valid(), "invariant");
760
761 add_method_info(writer,
762 utf8_indexes[UTF8_REQ_shouldCommit],
763 utf8_indexes[UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC],
764 utf8_indexes[UTF8_REQ_Code],
765 boolean_method_code_attribute,
766 sizeof(boolean_method_code_attribute));
767 assert(writer.is_valid(), "invariant");
768 return number_of_new_methods;
769 }
770
771 static void adjust_exception_table(JfrBigEndianWriter& writer, u2 bci_adjustment_offset, const Method* method, TRAPS) {
772 const u2 ex_table_length = method != NULL ? (u2)method->exception_table_length() : 0;
773 writer.write<u2>(ex_table_length); // Exception table length
774 if (ex_table_length > 0) {
775 assert(method != NULL, "invariant");
776 const ExceptionTableElement* const ex_elements = method->exception_table_start();
777 for (int i = 0; i < ex_table_length; ++i) {
778 assert(ex_elements != NULL, "invariant");
779 writer.write<u2>(ex_elements[i].start_pc + bci_adjustment_offset);
780 writer.write<u2>(ex_elements[i].end_pc + bci_adjustment_offset);
781 writer.write<u2>(ex_elements[i].handler_pc + bci_adjustment_offset);
782 writer.write<u2>(ex_elements[i].catch_type_index); // no adjustment
783 }
784 }
785 }
786
787 enum StackMapFrameTypes {
788 SAME_FRAME_BEGIN = 0,
789 SAME_FRAME_END = 63,
790 SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN = 64,
791 SAME_LOCALS_1_STACK_ITEM_FRAME_END = 127,
792 SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247,
793 CHOP_FRAME_BEGIN = 248,
794 CHOP_FRAME_END = 250,
795 SAME_FRAME_EXTENDED = 251,
796 APPEND_FRAME_BEGIN = 252,
797 APPEND_FRAME_END = 254,
798 FULL_FRAME = 255
799 };
800
801 static void adjust_stack_map(JfrBigEndianWriter& writer,
802 Array<u1>* stack_map,
803 const u2* utf8_indexes,
804 u2 bci_adjustment_offset,
805 TRAPS) {
806 assert(stack_map != NULL, "invariant");
807 assert(utf8_indexes != NULL, "invariant");
808 writer.write<u2>(utf8_indexes[UTF8_OPT_StackMapTable]);
809 const jlong stack_map_attrib_len_offset = writer.current_offset();
810 writer.reserve(sizeof(u4));
811 StackMapStream stream(stack_map);
812 const u2 stack_map_entries = stream.get_u2(THREAD);
813 // number of entries
814 writer.write<u2>(stack_map_entries); // new stack map entry added
815 const u1 frame_type = stream.get_u1(THREAD);
816 // SAME_FRAME and SAME_LOCALS_1_STACK_ITEM_FRAME encode
817 // their offset_delta into the actual frame type itself.
818 // If such a frame type is the first frame, then we transform
819 // it to a SAME_FRAME_EXTENDED or a SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED frame.
820 // This is done in order to not overflow frame types accidentally
821 // when adjusting the offset_delta. In changing the frame types,
822 // we can work with an explicit u2 offset_delta field (like the other frame types)
823 if (frame_type <= SAME_FRAME_END) {
824 writer.write<u1>(SAME_FRAME_EXTENDED);
825 writer.write<u2>(frame_type + bci_adjustment_offset);
826 } else if (frame_type >= SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN &&
827 frame_type <= SAME_LOCALS_1_STACK_ITEM_FRAME_END) {
828 writer.write<u1>(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED);
829 writer.write<u2>((frame_type - SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN) + bci_adjustment_offset);
830 } else if (frame_type >= SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
831 // SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED to FULL_FRAME
832 // has a u2 offset_delta field
833 writer.write<u1>(frame_type);
834 writer.write<u2>(stream.get_u2(THREAD) + bci_adjustment_offset);
835 } else {
836 assert(false, "stackMapFrame type is invalid");
837 }
838
839 while (!stream.at_end()) {
840 writer.write<u1>(stream.get_u1(THREAD));
841 }
842
843 u4 stack_map_attrib_len = writer.current_offset() - stack_map_attrib_len_offset;
844 // the stack_map_table_attributes_length value is exclusive
845 stack_map_attrib_len -= sizeof(u4);
846 writer.write_at_offset(stack_map_attrib_len, stack_map_attrib_len_offset);
847 }
848
849 static void adjust_line_number_table(JfrBigEndianWriter& writer,
850 const u2* utf8_indexes,
851 u4 bci_adjustement_offset,
852 const Method* method,
853 TRAPS) {
854 assert(utf8_indexes != NULL, "invariant");
855 assert(method != NULL, "invariant");
856 assert(method->has_linenumber_table(), "invariant");
857 writer.write(utf8_indexes[UTF8_OPT_LineNumberTable]);
858 const jlong lnt_attributes_length_offset = writer.current_offset();
859 writer.reserve(sizeof(u4));
860 const jlong lnt_attributes_entries_offset = writer.current_offset();
861 writer.reserve(sizeof(u2));
862 u1* lnt = method->compressed_linenumber_table();
863 CompressedLineNumberReadStream lnt_stream(lnt);
864 u2 line_number_table_entries = 0;
865 while (lnt_stream.read_pair()) {
866 ++line_number_table_entries;
867 const u2 bci = (u2)lnt_stream.bci();
868 writer.write<u2>(bci + (u2)bci_adjustement_offset);
869 writer.write<u2>((u2)lnt_stream.line());
870 }
871 writer.write_at_offset(line_number_table_entries, lnt_attributes_entries_offset);
872 u4 lnt_table_attributes_len = writer.current_offset() - lnt_attributes_length_offset;
873 // the line_number_table_attributes_length value is exclusive
874 lnt_table_attributes_len -= sizeof(u4);
875 writer.write_at_offset(lnt_table_attributes_len, lnt_attributes_length_offset);
876 }
877
878 // returns the number of lvtt entries
879 static u2 adjust_local_variable_table(JfrBigEndianWriter& writer,
880 const u2* utf8_indexes,
881 u2 bci_adjustment_offset,
882 const Method* method,
883 TRAPS) {
884 assert(utf8_indexes != NULL, "invariant");
885 assert(method != NULL, "invariant");
886 assert(method->has_localvariable_table(), "invariant");
887 writer.write<u2>(utf8_indexes[UTF8_OPT_LocalVariableTable]);
888 const jlong lvt_attributes_length_offset = writer.current_offset();
889 writer.reserve(sizeof(u4));
890 const int lvt_len = method->localvariable_table_length();
891 writer.write<u2>((u2)lvt_len);
892 const LocalVariableTableElement* table = method->localvariable_table_start();
893 assert(table != NULL, "invariant");
894 u2 num_lvtt_entries = 0;
895 for (int i = 0; i < lvt_len; ++i) {
896 writer.write<u2>(table[i].start_bci + bci_adjustment_offset);
897 writer.write<u2>(table[i].length);
898 writer.write<u2>(table[i].name_cp_index);
899 writer.write<u2>(table[i].descriptor_cp_index);
900 writer.write<u2>(table[i].slot);
901 if (table[i].signature_cp_index > 0) {
902 ++num_lvtt_entries;
903 }
904 }
905 u4 lvt_table_attributes_len = writer.current_offset() - lvt_attributes_length_offset;
906 // the lvt_table_attributes_length value is exclusive
907 lvt_table_attributes_len -= sizeof(u4);
908 writer.write_at_offset(lvt_table_attributes_len, lvt_attributes_length_offset);
909 return num_lvtt_entries;
910 }
911
912 static void adjust_local_variable_type_table(JfrBigEndianWriter& writer,
913 const u2* utf8_indexes,
914 u2 bci_adjustment_offset,
915 u2 num_lvtt_entries,
916 const Method* method,
917 TRAPS) {
918 assert(num_lvtt_entries > 0, "invariant");
919 writer.write<u2>(utf8_indexes[UTF8_OPT_LocalVariableTypeTable]);
920 const jlong lvtt_attributes_length_offset = writer.current_offset();
921 writer.reserve(sizeof(u4));
922 writer.write<u2>(num_lvtt_entries);
923 const LocalVariableTableElement* table = method->localvariable_table_start();
924 assert(table != NULL, "invariant");
925 const int lvt_len = method->localvariable_table_length();
926 for (int i = 0; i < lvt_len; ++i) {
927 if (table[i].signature_cp_index > 0) {
928 writer.write<u2>(table[i].start_bci + bci_adjustment_offset);
929 writer.write<u2>(table[i].length);
930 writer.write<u2>(table[i].name_cp_index);
931 writer.write<u2>(table[i].signature_cp_index);
932 writer.write<u2>(table[i].slot);
933 }
934 }
935 u4 lvtt_table_attributes_len = writer.current_offset() - lvtt_attributes_length_offset;
936 // the lvtt_table_attributes_length value is exclusive
937 lvtt_table_attributes_len -= sizeof(u4);
938 writer.write_at_offset(lvtt_table_attributes_len, lvtt_attributes_length_offset);
939 }
940
941 static void adjust_code_attributes(JfrBigEndianWriter& writer,
942 const u2* utf8_indexes,
943 u2 bci_adjustment_offset,
944 const Method* clinit_method,
945 TRAPS) {
946 // "Code" attributes
947 assert(utf8_indexes != NULL, "invariant");
948 const jlong code_attributes_offset = writer.current_offset();
949 writer.reserve(sizeof(u2));
950 u2 number_of_code_attributes = 0;
951 if (clinit_method != NULL) {
952 Array<u1>* stack_map = clinit_method->stackmap_data();
953 if (stack_map != NULL) {
954 ++number_of_code_attributes;
955 adjust_stack_map(writer, stack_map, utf8_indexes, bci_adjustment_offset, THREAD);
956 assert(writer.is_valid(), "invariant");
957 }
958 if (clinit_method != NULL && clinit_method->has_linenumber_table()) {
959 ++number_of_code_attributes;
960 adjust_line_number_table(writer, utf8_indexes, bci_adjustment_offset, clinit_method, THREAD);
961 assert(writer.is_valid(), "invariant");
962 }
963 if (clinit_method != NULL && clinit_method->has_localvariable_table()) {
964 ++number_of_code_attributes;
965 const u2 num_of_lvtt_entries = adjust_local_variable_table(writer, utf8_indexes, bci_adjustment_offset, clinit_method, THREAD);
966 assert(writer.is_valid(), "invariant");
967 if (num_of_lvtt_entries > 0) {
968 ++number_of_code_attributes;
969 adjust_local_variable_type_table(writer, utf8_indexes, bci_adjustment_offset, num_of_lvtt_entries, clinit_method, THREAD);
970 assert(writer.is_valid(), "invariant");
971 }
972 }
973 }
974
975 // Store the number of code_attributes
976 writer.write_at_offset(number_of_code_attributes, code_attributes_offset);
977 }
978
979 static jlong insert_clinit_method(const InstanceKlass* ik,
980 const ClassFileParser& parser,
981 JfrBigEndianWriter& writer,
982 u2 orig_constant_pool_len,
983 const u2* utf8_indexes,
984 const u2 register_method_ref_index,
985 const Method* clinit_method,
986 TRAPS) {
987 assert(utf8_indexes != NULL, "invariant");
988 // The injected code length is always this value.
989 // This is to ensure that padding can be done
990 // where needed and to simplify size calculations.
991 static const u2 injected_code_length = 8;
992 const u2 name_index = utf8_indexes[UTF8_REQ_clinit];
993 const u2 desc_index = utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC];
994 const u2 max_stack = MAX2(clinit_method != NULL ? clinit_method->verifier_max_stack() : 1, 1);
995 const u2 max_locals = MAX2(clinit_method != NULL ? clinit_method->max_locals() : 0, 0);
996 const u2 orig_bytecodes_length = clinit_method != NULL ? (u2)clinit_method->code_size() : 0;
997 const address orig_bytecodes = clinit_method != NULL ? clinit_method->code_base() : NULL;
998 const u2 new_code_length = injected_code_length + orig_bytecodes_length;
999 DEBUG_ONLY(const jlong start_offset = writer.current_offset();)
1000 writer.write<u2>(JVM_ACC_STATIC); // flags
1001 writer.write<u2>(name_index);
1002 writer.write<u2>(desc_index);
1003 writer.write<u2>((u2)0x1); // attributes_count // "Code"
1004 assert(writer.is_valid(), "invariant");
1005 DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)
1006 // "Code" attribute
1007 writer.write<u2>(utf8_indexes[UTF8_REQ_Code]); // "Code"
1008 const jlong code_attribute_length_offset = writer.current_offset();
1009 writer.reserve(sizeof(u4));
1010 writer.write<u2>(max_stack); // max stack
1011 writer.write<u2>(max_locals); // max locals
1012 writer.write<u4>((u4)new_code_length); // code length
1013
1014 /* BEGIN CLINIT CODE */
1015
1016 // Note the use of ldc_w here instead of ldc.
1017 // This is to handle all values of "this_class_index"
1018 writer.write<u1>((u1)Bytecodes::_ldc_w);
1019 writer.write<u2>((u2)parser.this_class_index()); // load constant "this class"
1020 writer.write<u1>((u1)Bytecodes::_invokestatic);
1021 // invoke "FlightRecorder.register(Ljava/lang/Class;")
1022 writer.write<u2>(register_method_ref_index);
1023 if (clinit_method == NULL) {
1024 writer.write<u1>((u1)Bytecodes::_nop);
1025 writer.write<u1>((u1)Bytecodes::_return);
1026 } else {
1027 // If we are pre-pending to original code,
1028 // do padding to minimize disruption to the original.
1029 // It might have dependencies on 4-byte boundaries
1030 // i.e. lookupswitch and tableswitch instructions
1031 writer.write<u1>((u1)Bytecodes::_nop);
1032 writer.write<u1>((u1)Bytecodes::_nop);
1033 // insert original clinit code
1034 writer.bytes(orig_bytecodes, orig_bytecodes_length);
1035 }
1036
1037 /* END CLINIT CODE */
1038
1039 assert(writer.is_valid(), "invariant");
1040 adjust_exception_table(writer, injected_code_length, clinit_method, THREAD);
1041 assert(writer.is_valid(), "invariant");
1042 adjust_code_attributes(writer, utf8_indexes, injected_code_length, clinit_method, THREAD);
1043 assert(writer.is_valid(), "invariant");
1044 u4 code_attribute_len = writer.current_offset() - code_attribute_length_offset;
1045 // the code_attribute_length value is exclusive
1046 code_attribute_len -= sizeof(u4);
1047 writer.write_at_offset(code_attribute_len, code_attribute_length_offset);
1048 return writer.current_offset();
1049 }
1050
1051 // Caller needs ResourceMark
1052 static ClassFileStream* create_new_bytes_for_event_klass(const InstanceKlass* ik, const ClassFileParser& parser, TRAPS) {
1053 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
1054 static const u2 public_final_flag_mask = JVM_ACC_PUBLIC | JVM_ACC_FINAL;
1055 ClassFileStream* orig_stream = const_cast<ClassFileStream*>(parser.clone_stream());
1056 const int orig_stream_length = orig_stream->length();
1057 // allocate an identically sized buffer
1058 u1* const new_buffer = NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(THREAD, u1, orig_stream_length);
1059 if (new_buffer == NULL) {
1060 return NULL;
1061 }
1062 assert(new_buffer != NULL, "invariant");
1063 // memcpy the entire [B
1064 memcpy(new_buffer, orig_stream->buffer(), orig_stream_length);
1065 const u2 orig_cp_len = position_stream_after_cp(orig_stream);
1066 assert(orig_cp_len > 0, "invariant");
1067 assert(orig_stream->current_offset() > 0, "invariant");
1068 orig_stream->skip_u2_fast(3); // access_flags, this_class_index, super_class_index
1069 const u2 iface_len = orig_stream->get_u2_fast();
1070 orig_stream->skip_u2_fast(iface_len);
1071 // fields len
1072 const u2 orig_fields_len = orig_stream->get_u2_fast();
1073 // fields
1074 for (u2 i = 0; i < orig_fields_len; ++i) {
1075 orig_stream->skip_u2_fast(3);
1076 const u2 attrib_info_len = orig_stream->get_u2_fast();
1077 for (u2 j = 0; j < attrib_info_len; ++j) {
1078 orig_stream->skip_u2_fast(1);
1079 const u4 attrib_len = orig_stream->get_u4_fast();
1080 orig_stream->skip_u1_fast(attrib_len);
1081 }
1082 }
1083 // methods
1084 const u2 orig_methods_len = orig_stream->get_u2_fast();
1085 for (u2 i = 0; i < orig_methods_len; ++i) {
1086 const u4 access_flag_offset = orig_stream->current_offset();
1087 const u2 flags = orig_stream->get_u2_fast();
1088 // Rewrite JVM_ACC_FINAL -> JVM_ACC_PUBLIC
1089 if (public_final_flag_mask == flags) {
1090 JfrBigEndianWriter accessflagsrewriter(new_buffer + access_flag_offset, sizeof(u2));
1091 accessflagsrewriter.write<u2>(JVM_ACC_PUBLIC);
1092 assert(accessflagsrewriter.is_valid(), "invariant");
1093 }
1094 orig_stream->skip_u2_fast(2);
1095 const u2 attributes_count = orig_stream->get_u2_fast();
1096 for (u2 j = 0; j < attributes_count; ++j) {
1097 orig_stream->skip_u2_fast(1);
1098 const u4 attrib_len = orig_stream->get_u4_fast();
1099 orig_stream->skip_u1_fast(attrib_len);
1100 }
1101 }
1102 return new ClassFileStream(new_buffer, orig_stream_length, NULL);
1103 }
1104
1105 // Attempt to locate an existing UTF8_INFO mapping the utf8_constant.
1106 // If no UTF8_INFO exists, add (append) a new one to the constant pool.
1107 static u2 find_or_add_utf8_info(JfrBigEndianWriter& writer,
1108 const InstanceKlass* ik,
1109 const char* const utf8_constant,
1110 u2 orig_cp_len,
1111 u2& added_cp_entries,
1112 TRAPS) {
1113 assert(utf8_constant != NULL, "invariant");
1114 TempNewSymbol utf8_sym = SymbolTable::new_symbol(utf8_constant, THREAD);
1115 // lookup existing
1116 const int utf8_orig_idx = utf8_info_index(ik, utf8_sym, THREAD);
1117 if (utf8_orig_idx != invalid_cp_index) {
1118 // existing constant pool entry found
1119 return utf8_orig_idx;
1120 }
1121 // no existing match, need to add a new utf8 cp entry
1122 assert(invalid_cp_index == utf8_orig_idx, "invariant");
1123 // add / append new
1124 return add_utf8_info(writer, utf8_constant, orig_cp_len, added_cp_entries);
1125 }
1126
1127 /*
1128 * This routine will resolve the required utf8_constants array
1129 * to their constant pool indexes (mapping to their UTF8_INFO's)
1130 * Only if a constant is actually needed and does not already exist
1131 * will it be added.
1132 *
1133 * The passed in indexes array will be populated with the resolved indexes.
1134 * The number of newly added constant pool entries is returned.
1135 */
1136 static u2 resolve_utf8_indexes(JfrBigEndianWriter& writer,
1137 const InstanceKlass* ik,
1138 u2* const utf8_indexes,
1139 u2 orig_cp_len,
1140 const Method* clinit_method,
1141 TRAPS) {
1142 assert(utf8_indexes != NULL, "invariant");
1143 u2 added_cp_entries = 0;
1144 // resolve all required symbols
1145 for (u2 index = 0; index < NOF_UTF8_REQ_SYMBOLS; ++index) {
1146 utf8_indexes[index] = find_or_add_utf8_info(writer,
1147 ik,
1148 utf8_constants[index],
1149 orig_cp_len,
1150 added_cp_entries,
1151 THREAD);
1152 }
1153 // Now determine optional constants (mainly "Code" attributes)
1154 if (clinit_method != NULL && clinit_method->has_stackmap_table()) {
1155 utf8_indexes[UTF8_OPT_StackMapTable] =
1156 find_or_add_utf8_info(writer,
1157 ik,
1158 utf8_constants[UTF8_OPT_StackMapTable],
1159 orig_cp_len,
1160 added_cp_entries,
1161 THREAD);
1162 } else {
1163 utf8_indexes[UTF8_OPT_StackMapTable] = invalid_cp_index;
1164 }
1165
1166 if (clinit_method != NULL && clinit_method->has_linenumber_table()) {
1167 utf8_indexes[UTF8_OPT_LineNumberTable] =
1168 find_or_add_utf8_info(writer,
1169 ik,
1170 utf8_constants[UTF8_OPT_LineNumberTable],
1171 orig_cp_len,
1172 added_cp_entries,
1173 THREAD);
1174 } else {
1175 utf8_indexes[UTF8_OPT_LineNumberTable] = invalid_cp_index;
1176 }
1177
1178 if (clinit_method != NULL && clinit_method->has_localvariable_table()) {
1179 utf8_indexes[UTF8_OPT_LocalVariableTable] =
1180 find_or_add_utf8_info(writer,
1181 ik,
1182 utf8_constants[UTF8_OPT_LocalVariableTable],
1183 orig_cp_len,
1184 added_cp_entries,
1185 THREAD);
1186
1187 utf8_indexes[UTF8_OPT_LocalVariableTypeTable] =
1188 find_or_add_utf8_info(writer,
1189 ik,
1190 utf8_constants[UTF8_OPT_LocalVariableTypeTable],
1191 orig_cp_len,
1192 added_cp_entries,
1193 THREAD);
1194 } else {
1195 utf8_indexes[UTF8_OPT_LocalVariableTable] = invalid_cp_index;
1196 utf8_indexes[UTF8_OPT_LocalVariableTypeTable] = invalid_cp_index;
1197 }
1198
1199 return added_cp_entries;
1200 }
1201
1202 static u1* new_bytes_for_lazy_instrumentation(InstanceKlass* ik,
1203 const ClassFileParser& parser,
1204 jint& size_of_new_bytes,
1205 TRAPS) {
1206 assert(ik != NULL, "invariant");
1207 // If the class already has a clinit method
1208 // we need to take that into account
1209 const Method* clinit_method = ik->class_initializer();
1210 const bool register_klass = should_register_klass(ik);
1211 ClassFileStream* orig_stream = const_cast<ClassFileStream*>(parser.clone_stream());
1212 const int orig_stream_size = orig_stream->length();
1213 assert(orig_stream->current_offset() == 0, "invariant");
1214 const u2 orig_cp_len = position_stream_after_cp(orig_stream);
1215 assert(orig_cp_len > 0, "invariant");
1216 assert(orig_stream->current_offset() > 0, "invariant");
1217 // Dimension and allocate a working byte buffer
1218 // to be used in building up a modified class [B.
1219 const jint new_buffer_size = extra_stream_bytes + orig_stream_size;
1220 u1* const new_buffer = NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(THREAD, u1, new_buffer_size);
1221 if (new_buffer == NULL) {
1222 log_error(jfr, system) ("Thread local allocation (native) for " SIZE_FORMAT
1223 " bytes failed in JfrClassAdapter::on_klass_creation", (size_t)new_buffer_size);
1224 return NULL;
1225 }
1226 assert(new_buffer != NULL, "invariant");
1227 // [B wrapped in a big endian writer
1228 JfrBigEndianWriter writer(new_buffer, new_buffer_size);
1229 assert(writer.current_offset() == 0, "invariant");
1230 const u4 orig_access_flag_offset = orig_stream->current_offset();
1231 // Copy original stream from the beginning up to AccessFlags
1232 // This means the original constant pool contents are copied unmodified
1233 writer.bytes(orig_stream->buffer(), orig_access_flag_offset);
1234 assert(writer.is_valid(), "invariant");
1235 assert(writer.current_offset() == orig_access_flag_offset, "invariant"); // same positions
1236 // Our writer now sits just after the last original constant pool entry.
1237 // I.e. we are in a good position to append new constant pool entries
1238 // This array will contain the resolved indexes
1239 // in order to reference UTF8_INFO's needed
1240 u2 utf8_indexes[NOF_UTF8_SYMBOLS];
1241 // Resolve_utf8_indexes will be conservative in attempting to
1242 // locate an existing UTF8_INFO; it will only append constants
1243 // that is absolutely required
1244 u2 number_of_new_constants = resolve_utf8_indexes(writer, ik, utf8_indexes, orig_cp_len, clinit_method, THREAD);
1245 // UTF8_INFO entries now added to the constant pool
1246 // In order to invoke a method we would need additional
1247 // constants, JVM_CONSTANT_Class, JVM_CONSTANT_NameAndType
1248 // and JVM_CONSTANT_Methodref.
1249 const u2 flr_register_method_ref_index =
1250 register_klass ?
1251 add_flr_register_method_constants(writer,
1252 utf8_indexes,
1253 orig_cp_len,
1254 number_of_new_constants,
1255 THREAD) : invalid_cp_index;
1256
1257 // New constant pool entries added and all UTF8_INFO indexes resolved
1258 // Now update the class file constant_pool_count with an updated count
1259 writer.write_at_offset<u2>(orig_cp_len + number_of_new_constants, 8);
1260 assert(writer.is_valid(), "invariant");
1261 orig_stream->skip_u2_fast(3); // access_flags, this_class_index, super_class_index
1262 const u2 iface_len = orig_stream->get_u2_fast(); // interfaces
1263 orig_stream->skip_u2_fast(iface_len);
1264 const u4 orig_fields_len_offset = orig_stream->current_offset();
1265 // Copy from AccessFlags up to and including interfaces
1266 writer.bytes(orig_stream->buffer() + orig_access_flag_offset,
1267 orig_fields_len_offset - orig_access_flag_offset);
1268 assert(writer.is_valid(), "invariant");
1269 const jlong new_fields_len_offset = writer.current_offset();
1270 const u2 orig_fields_len = position_stream_after_fields(orig_stream);
1271 u4 orig_method_len_offset = orig_stream->current_offset();
1272 // Copy up to and including fields
1273 writer.bytes(orig_stream->buffer() + orig_fields_len_offset, orig_method_len_offset - orig_fields_len_offset);
1274 assert(writer.is_valid(), "invariant");
1275 // We are sitting just after the original number of field_infos
1276 // so this is a position where we can add (append) new field_infos
1277 const u2 number_of_new_fields = add_field_infos(writer, utf8_indexes);
1278 assert(writer.is_valid(), "invariant");
1279 const jlong new_method_len_offset = writer.current_offset();
1280 // Additional field_infos added, update classfile fields_count
1281 writer.write_at_offset<u2>(orig_fields_len + number_of_new_fields, new_fields_len_offset);
1282 assert(writer.is_valid(), "invariant");
1283 // Our current location is now at classfile methods_count
1284 const u2 orig_methods_len = position_stream_after_methods(writer,
1285 orig_stream,
1286 utf8_indexes,
1287 register_klass,
1288 clinit_method,
1289 orig_method_len_offset);
1290 const u4 orig_attributes_count_offset = orig_stream->current_offset();
1291 // Copy existing methods
1292 writer.bytes(orig_stream->buffer() + orig_method_len_offset, orig_attributes_count_offset - orig_method_len_offset);
1293 assert(writer.is_valid(), "invariant");
1294 // We are sitting just after the original number of method_infos
1295 // so this is a position where we can add (append) new method_infos
1296 u2 number_of_new_methods = add_method_infos(writer, utf8_indexes);
1297
1298 // We have just added the new methods.
1299 //
1300 // What about the state of <clinit>?
1301 // We would need to do:
1302 // 1. Nothing (@Registered(false) annotation)
1303 // 2. Build up a new <clinit> - and if the original class already contains a <clinit>,
1304 // merging will be neccessary.
1305 //
1306 if (register_klass) {
1307 insert_clinit_method(ik, parser, writer, orig_cp_len, utf8_indexes, flr_register_method_ref_index, clinit_method, THREAD);
1308 }
1309 number_of_new_methods += clinit_method != NULL ? 0 : register_klass ? 1 : 0;
1310 // Update classfile methods_count
1311 writer.write_at_offset<u2>(orig_methods_len + number_of_new_methods, new_method_len_offset);
1312 assert(writer.is_valid(), "invariant");
1313 // Copy last remaining bytes
1314 writer.bytes(orig_stream->buffer() + orig_attributes_count_offset, orig_stream_size - orig_attributes_count_offset);
1315 assert(writer.is_valid(), "invariant");
1316 assert(writer.current_offset() > orig_stream->length(), "invariant");
1317 size_of_new_bytes = (jint)writer.current_offset();
1318 return new_buffer;
1319 }
1320
1321 static void log_pending_exception(oop throwable) {
1322 assert(throwable != NULL, "invariant");
1323 oop msg = java_lang_Throwable::message(throwable);
1324 if (msg != NULL) {
1325 char* text = java_lang_String::as_utf8_string(msg);
1326 if (text != NULL) {
1327 log_error(jfr, system) ("%s", text);
1328 }
1329 }
1330 }
1331
1332 static bool should_force_instrumentation() {
1333 return !JfrOptionSet::allow_event_retransforms() || JfrEventClassTransformer::is_force_instrumentation();
1334 }
1335
1336 static ClassFileStream* create_new_bytes_for_subklass(InstanceKlass* ik, const ClassFileParser& parser, Thread* t) {
1337 assert(JdkJfrEvent::is_a(ik), "invariant");
1338 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(t));
1339 jint size_of_new_bytes = 0;
1340 u1* new_bytes = new_bytes_for_lazy_instrumentation(ik, parser, size_of_new_bytes, t);
1341 if (new_bytes == NULL) {
1342 return NULL;
1343 }
1344 assert(new_bytes != NULL, "invariant");
1345 assert(size_of_new_bytes > 0, "invariant");
1346
1347 bool force_instrumentation = should_force_instrumentation();
1348 if (Jfr::is_recording() || force_instrumentation) {
1349 jint size_instrumented_data = 0;
1350 unsigned char* instrumented_data = NULL;
1351 const jclass super = (jclass)JNIHandles::make_local(ik->super()->java_mirror());
1352 JfrUpcalls::new_bytes_eager_instrumentation(TRACE_ID(ik),
1353 force_instrumentation,
1354 super,
1355 size_of_new_bytes,
1356 new_bytes,
1357 &size_instrumented_data,
1358 &instrumented_data,
1359 t);
1360 if (t->has_pending_exception()) {
1361 log_pending_exception(t->pending_exception());
1362 t->clear_pending_exception();
1363 return NULL;
1364 }
1365 assert(instrumented_data != NULL, "invariant");
1366 assert(size_instrumented_data > 0, "invariant");
1367 return new ClassFileStream(instrumented_data, size_instrumented_data, NULL);
1368 }
1369 return new ClassFileStream(new_bytes, size_of_new_bytes, NULL);
1370 }
1371
1372 static bool cache_bytes(InstanceKlass* ik, ClassFileStream* new_stream, InstanceKlass* new_ik, TRAPS) {
1373 assert(ik != NULL, "invariant");
1374 assert(new_ik != NULL, "invariant");
1375 assert(new_ik->name() != NULL, "invariant");
1376 assert(new_stream != NULL, "invariant");
1377 assert(!HAS_PENDING_EXCEPTION, "invariant");
1378 static const bool can_retransform = JfrOptionSet::allow_retransforms();
1379 if (!can_retransform) {
1380 return true;
1381 }
1382 const jint stream_len = new_stream->length();
1383 JvmtiCachedClassFileData* p =
1384 (JvmtiCachedClassFileData*)NEW_C_HEAP_ARRAY_RETURN_NULL(u1, offset_of(JvmtiCachedClassFileData, data) + stream_len, mtInternal);
1385 if (p == NULL) {
1386 log_error(jfr, system)("Allocation using C_HEAP_ARRAY for " SIZE_FORMAT
1387 " bytes failed in JfrClassAdapter::on_klass_creation", (size_t)offset_of(JvmtiCachedClassFileData, data) + stream_len);
1388 return false;
1389 }
1390 p->length = stream_len;
1391 memcpy(p->data, new_stream->buffer(), stream_len);
1392 new_ik->set_cached_class_file(p);
1393 JvmtiCachedClassFileData* const cached_class_data = ik->get_cached_class_file();
1394 if (cached_class_data != NULL) {
1395 os::free(cached_class_data);
1396 ik->set_cached_class_file(NULL);
1397 }
1398 return true;
1399 }
1400
1401 static instanceKlassHandle create_new_instance_klass(InstanceKlass* ik, ClassFileStream* stream, TRAPS) {
1402 assert(stream != NULL, "invariant");
1403 ResourceMark rm(THREAD);
1404 ClassLoaderData* const cld = ik->class_loader_data();
1405 Handle pd(THREAD, ik->protection_domain());
1406 Symbol* const class_name = ik->name();
1407 const char* const klass_name = class_name != NULL ? class_name->as_C_string() : "";
1408 TempNewSymbol parsed_name = NULL;
1409 ClassFileParser new_parser(stream);
1410 if (HAS_PENDING_EXCEPTION) {
1411 log_pending_exception(PENDING_EXCEPTION);
1412 CLEAR_PENDING_EXCEPTION;
1413 return NULL;
1414 }
1415 instanceKlassHandle new_ik = new_parser.parseClassFile(class_name,
1416 cld,
1417 pd,
1418 parsed_name,
1419 true,
1420 THREAD);
1421 if (HAS_PENDING_EXCEPTION) {
1422 log_pending_exception(PENDING_EXCEPTION);
1423 CLEAR_PENDING_EXCEPTION;
1424 return NULL;
1425 }
1426 assert(new_ik() != NULL, "invariant");
1427 assert(new_ik->name() != NULL, "invariant");
1428 assert(strncmp(ik->name()->as_C_string(), new_ik()->name()->as_C_string(), strlen(ik->name()->as_C_string())) == 0, "invariant");
1429 return cache_bytes(ik, stream, new_ik(), THREAD) ? new_ik : NULL;
1430 }
1431
1432 static void rewrite_klass_pointer(instanceKlassHandle& ik, instanceKlassHandle new_ik, ClassFileParser& parser, TRAPS) {
1433 assert(ik() != NULL, "invariant");
1434 assert(new_ik() != NULL, "invariant");
1435 assert(new_ik->name() != NULL, "invariant");
1436 assert(JdkJfrEvent::is(new_ik()) || JdkJfrEvent::is_subklass(new_ik()), "invariant");
1437 assert(!HAS_PENDING_EXCEPTION, "invariant");
1438 // assign original InstanceKlass* back onto "its" parser object for proper destruction
1439 parser.set_klass_to_deallocate(ik());
1440 // now rewrite original pointer to newly created InstanceKlass
1441 ik = new_ik;
1442 }
1443
1444 // During retransform/redefine, copy the Method specific trace flags
1445 // from the previous ik ("the original klass") to the new ik ("the scratch_klass").
1446 // The open code for retransform/redefine does not know about these.
1447 // In doing this migration here, we ensure the new Methods (defined in scratch klass)
1448 // will carry over trace tags from the old Methods being replaced,
1449 // ensuring flag/tag continuity while being transparent to open code.
1450 static void copy_method_trace_flags(const InstanceKlass* the_original_klass, const InstanceKlass* the_scratch_klass) {
1451 assert(the_original_klass != NULL, "invariant");
1452 assert(the_scratch_klass != NULL, "invariant");
1453 assert(the_original_klass->name() == the_scratch_klass->name(), "invariant");
1454 const Array<Method*>* old_methods = the_original_klass->methods();
1455 const Array<Method*>* new_methods = the_scratch_klass->methods();
1456 const bool equal_array_length = old_methods->length() == new_methods->length();
1457 // The Method array has the property of being sorted.
1458 // If they are the same length, there is a one-to-one mapping.
1459 // If they are unequal, there was a method added (currently only
1460 // private static methods allowed to be added), use lookup.
1461 for (int i = 0; i < old_methods->length(); ++i) {
1462 const Method* const old_method = old_methods->at(i);
1463 Method* const new_method = equal_array_length ? new_methods->at(i) :
1464 the_scratch_klass->find_method(old_method->name(), old_method->signature());
1465 assert(new_method != NULL, "invariant");
1466 assert(new_method->name() == old_method->name(), "invariant");
1467 assert(new_method->signature() == old_method->signature(), "invariant");
1468 *new_method->trace_flags_addr() = old_method->trace_flags();
1469 assert(new_method->trace_flags() == old_method->trace_flags(), "invariant");
1470 }
1471 }
1472
1473 static bool is_retransforming(const InstanceKlass* ik, TRAPS) {
1474 assert(ik != NULL, "invariant");
1475 assert(JdkJfrEvent::is_a(ik), "invariant");
1476 Symbol* const name = ik->name();
1477 assert(name != NULL, "invariant");
1478 Handle class_loader(THREAD, ik->class_loader());
1479 Handle protection_domain(THREAD, ik->protection_domain());
1480 // nota bene: use lock-free dictionary lookup
1481 const InstanceKlass* prev_ik = (const InstanceKlass*)SystemDictionary::find(name, class_loader, protection_domain, THREAD);
1482 if (prev_ik == NULL) {
1483 return false;
1484 }
1485 // an existing ik implies a retransform/redefine
1486 assert(prev_ik != NULL, "invariant");
1487 assert(JdkJfrEvent::is_a(prev_ik), "invariant");
1488 copy_method_trace_flags(prev_ik, ik);
1489 return true;
1490 }
1491
1492 // target for TRACE_KLASS_CREATION hook
1493 void JfrEventClassTransformer::on_klass_creation(instanceKlassHandle& ik, ClassFileParser& parser, TRAPS) {
1494 assert(ik() != NULL, "invariant");
1495 if (JdkJfrEvent::is(ik())) {
1496 ResourceMark rm(THREAD);
1497 HandleMark hm(THREAD);
1498 ClassFileStream* new_stream = create_new_bytes_for_event_klass(InstanceKlass::cast(ik()), parser, THREAD);
1499 if (new_stream == NULL) {
1500 log_error(jfr, system)("JfrClassAdapter: unable to create ClassFileStream");
1501 return;
1502 }
1503 assert(new_stream != NULL, "invariant");
1504 instanceKlassHandle new_ik = create_new_instance_klass(InstanceKlass::cast(ik()), new_stream, THREAD);
1505 if (new_ik() == NULL) {
1506 log_error(jfr, system)("JfrClassAdapter: unable to create InstanceKlass");
1507 return;
1508 }
1509 assert(new_ik() != NULL, "invariant");
1510 // We now need to explicitly tag the replaced klass as the jdk.jfr.Event klass
1511 assert(!JdkJfrEvent::is(new_ik()), "invariant");
1512 JdkJfrEvent::tag_as(new_ik());
1513 assert(JdkJfrEvent::is(new_ik()), "invariant");
1514 rewrite_klass_pointer(ik, new_ik, parser, THREAD);
1515 return;
1516 }
1517 assert(JdkJfrEvent::is_subklass(ik()), "invariant");
1518 if (is_retransforming(ik(), THREAD)) {
1519 // not the initial klass load
1520 return;
1521 }
1522 if (ik->is_abstract()) {
1523 // abstract classes are not instrumented
1524 return;
1525 }
1526 ResourceMark rm(THREAD);
1527 HandleMark hm(THREAD);
1528 ClassFileStream* const new_stream = create_new_bytes_for_subklass(ik(), parser, THREAD);
1529 if (NULL == new_stream) {
1530 log_error(jfr, system)("JfrClassAdapter: unable to create ClassFileStream");
1531 return;
1532 }
1533 assert(new_stream != NULL, "invariant");
1534 instanceKlassHandle new_ik = create_new_instance_klass(ik(), new_stream, THREAD);
1535 if (new_ik() == NULL) {
1536 log_error(jfr, system)("JfrClassAdapter: unable to create InstanceKlass");
1537 return;
1538 }
1539 assert(new_ik() != NULL, "invariant");
1540 // would have been tagged already as a subklass during the normal process of traceid assignment
1541 assert(JdkJfrEvent::is_subklass(new_ik()), "invariant");
1542 traceid id = ik->trace_id();
1543 ik->set_trace_id(0);
1544 new_ik->set_trace_id(id);
1545 rewrite_klass_pointer(ik, new_ik, parser, THREAD);
1546 }
1547
1548 static bool _force_instrumentation = false;
1549 void JfrEventClassTransformer::set_force_instrumentation(bool force_instrumentation) {
1550 _force_instrumentation = force_instrumentation;
1551 }
1552
1553 bool JfrEventClassTransformer::is_force_instrumentation() {
1554 return _force_instrumentation;
1555 }