1 /*
2 * Copyright (c) 2013, 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 "ci/ciMethodData.hpp"
28 #include "ci/ciReplay.hpp"
29 #include "ci/ciSymbol.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciUtilities.inline.hpp"
32 #include "classfile/symbolTable.hpp"
33 #include "compiler/compileBroker.hpp"
34 #include "memory/allocation.inline.hpp"
35 #include "memory/oopFactory.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "oops/constantPool.hpp"
38 #include "oops/method.inline.hpp"
39 #include "oops/oop.inline.hpp"
40 #include "runtime/fieldDescriptor.inline.hpp"
41 #include "runtime/handles.inline.hpp"
42 #include "utilities/copy.hpp"
43 #include "utilities/macros.hpp"
44 #include "utilities/utf8.hpp"
45
46 #ifndef PRODUCT
47
48 // ciReplay
49
50 typedef struct _ciMethodDataRecord {
51 const char* _klass_name;
52 const char* _method_name;
53 const char* _signature;
54
55 int _state;
56 int _current_mileage;
57
58 intptr_t* _data;
59 char* _orig_data;
60 Klass** _classes;
61 Method** _methods;
62 int* _classes_offsets;
63 int* _methods_offsets;
64 int _data_length;
65 int _orig_data_length;
66 int _classes_length;
67 int _methods_length;
68 } ciMethodDataRecord;
69
70 typedef struct _ciMethodRecord {
71 const char* _klass_name;
72 const char* _method_name;
73 const char* _signature;
74
75 int _instructions_size;
76 int _interpreter_invocation_count;
77 int _interpreter_throwout_count;
78 int _invocation_counter;
79 int _backedge_counter;
80 } ciMethodRecord;
81
82 typedef struct _ciInlineRecord {
83 const char* _klass_name;
84 const char* _method_name;
85 const char* _signature;
86
87 int _inline_depth;
88 int _inline_bci;
89 } ciInlineRecord;
90
91 class CompileReplay;
92 static CompileReplay* replay_state;
93
94 class CompileReplay : public StackObj {
95 private:
96 FILE* _stream;
97 Thread* _thread;
98 Handle _protection_domain;
99 Handle _loader;
100
101 GrowableArray<ciMethodRecord*> _ci_method_records;
102 GrowableArray<ciMethodDataRecord*> _ci_method_data_records;
103
104 // Use pointer because we may need to return inline records
105 // without destroying them.
106 GrowableArray<ciInlineRecord*>* _ci_inline_records;
107
108 const char* _error_message;
109
110 char* _bufptr;
111 char* _buffer;
112 int _buffer_length;
113 int _buffer_pos;
114
115 // "compile" data
116 ciKlass* _iklass;
117 Method* _imethod;
118 int _entry_bci;
119 int _comp_level;
120
121 public:
122 CompileReplay(const char* filename, TRAPS) {
123 _thread = THREAD;
124 _loader = Handle(_thread, SystemDictionary::java_system_loader());
125 _protection_domain = Handle();
126
127 _stream = fopen(filename, "rt");
128 if (_stream == NULL) {
129 fprintf(stderr, "ERROR: Can't open replay file %s\n", filename);
130 }
131
132 _ci_inline_records = NULL;
133 _error_message = NULL;
134
135 _buffer_length = 32;
136 _buffer = NEW_RESOURCE_ARRAY(char, _buffer_length);
137 _bufptr = _buffer;
138 _buffer_pos = 0;
139
140 _imethod = NULL;
141 _iklass = NULL;
142 _entry_bci = 0;
143 _comp_level = 0;
144
145 test();
146 }
147
148 ~CompileReplay() {
149 if (_stream != NULL) fclose(_stream);
150 }
151
152 void test() {
153 strcpy(_buffer, "1 2 foo 4 bar 0x9 \"this is it\"");
154 _bufptr = _buffer;
155 assert(parse_int("test") == 1, "what");
156 assert(parse_int("test") == 2, "what");
157 assert(strcmp(parse_string(), "foo") == 0, "what");
158 assert(parse_int("test") == 4, "what");
159 assert(strcmp(parse_string(), "bar") == 0, "what");
160 assert(parse_intptr_t("test") == 9, "what");
161 assert(strcmp(parse_quoted_string(), "this is it") == 0, "what");
162 }
163
164 bool had_error() {
165 return _error_message != NULL || _thread->has_pending_exception();
166 }
167
168 bool can_replay() {
169 return !(_stream == NULL || had_error());
170 }
171
172 void report_error(const char* msg) {
173 _error_message = msg;
174 // Restore the _buffer contents for error reporting
175 for (int i = 0; i < _buffer_pos; i++) {
176 if (_buffer[i] == '\0') _buffer[i] = ' ';
177 }
178 }
179
180 int parse_int(const char* label) {
181 if (had_error()) {
182 return 0;
183 }
184
185 int v = 0;
186 int read;
187 if (sscanf(_bufptr, "%i%n", &v, &read) != 1) {
188 report_error(label);
189 } else {
190 _bufptr += read;
191 }
192 return v;
193 }
194
195 intptr_t parse_intptr_t(const char* label) {
196 if (had_error()) {
197 return 0;
198 }
199
200 intptr_t v = 0;
201 int read;
202 if (sscanf(_bufptr, INTPTR_FORMAT "%n", &v, &read) != 1) {
203 report_error(label);
204 } else {
205 _bufptr += read;
206 }
207 return v;
208 }
209
210 void skip_ws() {
211 // Skip any leading whitespace
212 while (*_bufptr == ' ' || *_bufptr == '\t') {
213 _bufptr++;
214 }
215 }
216
217
218 char* scan_and_terminate(char delim) {
219 char* str = _bufptr;
220 while (*_bufptr != delim && *_bufptr != '\0') {
221 _bufptr++;
222 }
223 if (*_bufptr != '\0') {
224 *_bufptr++ = '\0';
225 }
226 if (_bufptr == str) {
227 // nothing here
228 return NULL;
229 }
230 return str;
231 }
232
233 char* parse_string() {
234 if (had_error()) return NULL;
235
236 skip_ws();
237 return scan_and_terminate(' ');
238 }
239
240 char* parse_quoted_string() {
241 if (had_error()) return NULL;
242
243 skip_ws();
244
245 if (*_bufptr == '"') {
246 _bufptr++;
247 return scan_and_terminate('"');
248 } else {
249 return scan_and_terminate(' ');
250 }
251 }
252
253 const char* parse_escaped_string() {
254 char* result = parse_quoted_string();
255 if (result != NULL) {
256 unescape_string(result);
257 }
258 return result;
259 }
260
261 // Look for the tag 'tag' followed by an
262 bool parse_tag_and_count(const char* tag, int& length) {
263 const char* t = parse_string();
264 if (t == NULL) {
265 return false;
266 }
267
268 if (strcmp(tag, t) != 0) {
269 report_error(tag);
270 return false;
271 }
272 length = parse_int("parse_tag_and_count");
273 return !had_error();
274 }
275
276 // Parse a sequence of raw data encoded as bytes and return the
277 // resulting data.
278 char* parse_data(const char* tag, int& length) {
279 int read_size = 0;
280 if (!parse_tag_and_count(tag, read_size)) {
281 return NULL;
282 }
283
284 int actual_size = sizeof(MethodData);
285 char *result = NEW_RESOURCE_ARRAY(char, actual_size);
286 int i = 0;
287 if (read_size != actual_size) {
288 tty->print_cr("Warning: ciMethodData parsing sees MethodData size %i in file, current is %i", read_size,
289 actual_size);
290 // Replay serializes the entire MethodData, but the data is at the end.
291 // If the MethodData instance size has changed, we can pad or truncate in the beginning
292 int padding = actual_size - read_size;
293 if (padding > 0) {
294 // pad missing data with zeros
295 tty->print_cr("- Padding MethodData");
296 for (; i < padding; i++) {
297 result[i] = 0;
298 }
299 } else if (padding < 0) {
300 // drop some data
301 tty->print_cr("- Truncating MethodData");
302 for (int j = 0; j < -padding; j++) {
303 int val = parse_int("data");
304 // discard val
305 }
306 }
307 }
308
309 assert(i < actual_size, "At least some data must remain to be copied");
310 for (; i < actual_size; i++) {
311 int val = parse_int("data");
312 result[i] = val;
313 }
314 length = actual_size;
315 return result;
316 }
317
318 // Parse a standard chunk of data emitted as:
319 // 'tag' <length> # # ...
320 // Where each # is an intptr_t item
321 intptr_t* parse_intptr_data(const char* tag, int& length) {
322 if (!parse_tag_and_count(tag, length)) {
323 return NULL;
324 }
325
326 intptr_t* result = NEW_RESOURCE_ARRAY(intptr_t, length);
327 for (int i = 0; i < length; i++) {
328 skip_ws();
329 intptr_t val = parse_intptr_t("data");
330 result[i] = val;
331 }
332 return result;
333 }
334
335 // Parse a possibly quoted version of a symbol into a symbolOop
336 Symbol* parse_symbol(TRAPS) {
337 const char* str = parse_escaped_string();
338 if (str != NULL) {
339 Symbol* sym = SymbolTable::lookup(str, (int)strlen(str), CHECK_NULL);
340 return sym;
341 }
342 return NULL;
343 }
344
345 // Parse a valid klass name and look it up
346 Klass* parse_klass(TRAPS) {
347 const char* str = parse_escaped_string();
348 Symbol* klass_name = SymbolTable::lookup(str, (int)strlen(str), CHECK_NULL);
349 if (klass_name != NULL) {
350 Klass* k = NULL;
351 if (_iklass != NULL) {
352 k = (Klass*)_iklass->find_klass(ciSymbol::make(klass_name->as_C_string()))->constant_encoding();
353 } else {
354 k = SystemDictionary::resolve_or_fail(klass_name, _loader, _protection_domain, true, THREAD);
355 }
356 if (HAS_PENDING_EXCEPTION) {
357 oop throwable = PENDING_EXCEPTION;
358 java_lang_Throwable::print(throwable, tty);
359 tty->cr();
360 report_error(str);
361 if (ReplayIgnoreInitErrors) {
362 CLEAR_PENDING_EXCEPTION;
363 _error_message = NULL;
364 }
365 return NULL;
366 }
367 return k;
368 }
369 return NULL;
370 }
371
372 // Lookup a klass
373 Klass* resolve_klass(const char* klass, TRAPS) {
374 Symbol* klass_name = SymbolTable::lookup(klass, (int)strlen(klass), CHECK_NULL);
375 return SystemDictionary::resolve_or_fail(klass_name, _loader, _protection_domain, true, THREAD);
376 }
377
378 // Parse the standard tuple of <klass> <name> <signature>
379 Method* parse_method(TRAPS) {
380 InstanceKlass* k = (InstanceKlass*)parse_klass(CHECK_NULL);
381 if (k == NULL) {
382 report_error("Can't find holder klass");
383 return NULL;
384 }
385 Symbol* method_name = parse_symbol(CHECK_NULL);
386 Symbol* method_signature = parse_symbol(CHECK_NULL);
387 Method* m = k->find_method(method_name, method_signature);
388 if (m == NULL) {
389 report_error("Can't find method");
390 }
391 return m;
392 }
393
394 int get_line(int c) {
395 while(c != EOF) {
396 if (_buffer_pos + 1 >= _buffer_length) {
397 int new_length = _buffer_length * 2;
398 // Next call will throw error in case of OOM.
399 _buffer = REALLOC_RESOURCE_ARRAY(char, _buffer, _buffer_length, new_length);
400 _buffer_length = new_length;
401 }
402 if (c == '\n') {
403 c = getc(_stream); // get next char
404 break;
405 } else if (c == '\r') {
406 // skip LF
407 } else {
408 _buffer[_buffer_pos++] = c;
409 }
410 c = getc(_stream);
411 }
412 // null terminate it, reset the pointer
413 _buffer[_buffer_pos] = '\0'; // NL or EOF
414 _buffer_pos = 0;
415 _bufptr = _buffer;
416 return c;
417 }
418
419 // Process each line of the replay file executing each command until
420 // the file ends.
421 void process(TRAPS) {
422 int line_no = 1;
423 int c = getc(_stream);
424 while(c != EOF) {
425 c = get_line(c);
426 process_command(THREAD);
427 if (had_error()) {
428 tty->print_cr("Error while parsing line %d: %s\n", line_no, _error_message);
429 if (ReplayIgnoreInitErrors) {
430 CLEAR_PENDING_EXCEPTION;
431 _error_message = NULL;
432 } else {
433 return;
434 }
435 }
436 line_no++;
437 }
438 }
439
440 void process_command(TRAPS) {
441 char* cmd = parse_string();
442 if (cmd == NULL) {
443 return;
444 }
445 if (strcmp("#", cmd) == 0) {
446 // ignore
447 } else if (strcmp("compile", cmd) == 0) {
448 process_compile(CHECK);
449 } else if (strcmp("ciMethod", cmd) == 0) {
450 process_ciMethod(CHECK);
451 } else if (strcmp("ciMethodData", cmd) == 0) {
452 process_ciMethodData(CHECK);
453 } else if (strcmp("staticfield", cmd) == 0) {
454 process_staticfield(CHECK);
455 } else if (strcmp("ciInstanceKlass", cmd) == 0) {
456 process_ciInstanceKlass(CHECK);
457 } else if (strcmp("instanceKlass", cmd) == 0) {
458 process_instanceKlass(CHECK);
459 #if INCLUDE_JVMTI
460 } else if (strcmp("JvmtiExport", cmd) == 0) {
461 process_JvmtiExport(CHECK);
462 #endif // INCLUDE_JVMTI
463 } else {
464 report_error("unknown command");
465 }
466 }
467
468 // validation of comp_level
469 bool is_valid_comp_level(int comp_level) {
470 const int msg_len = 256;
471 char* msg = NULL;
472 if (!is_compile(comp_level)) {
473 msg = NEW_RESOURCE_ARRAY(char, msg_len);
474 jio_snprintf(msg, msg_len, "%d isn't compilation level", comp_level);
475 } else if (!TieredCompilation && (comp_level != CompLevel_highest_tier)) {
476 msg = NEW_RESOURCE_ARRAY(char, msg_len);
477 switch (comp_level) {
478 case CompLevel_simple:
479 jio_snprintf(msg, msg_len, "compilation level %d requires Client VM or TieredCompilation", comp_level);
480 break;
481 case CompLevel_full_optimization:
482 jio_snprintf(msg, msg_len, "compilation level %d requires Server VM", comp_level);
483 break;
484 default:
485 jio_snprintf(msg, msg_len, "compilation level %d requires TieredCompilation", comp_level);
486 }
487 }
488 if (msg != NULL) {
489 report_error(msg);
490 return false;
491 }
492 return true;
493 }
494
495 // compile <klass> <name> <signature> <entry_bci> <comp_level> inline <count> <depth> <bci> <klass> <name> <signature> ...
496 void* process_inline(ciMethod* imethod, Method* m, int entry_bci, int comp_level, TRAPS) {
497 _imethod = m;
498 _iklass = imethod->holder();
499 _entry_bci = entry_bci;
500 _comp_level = comp_level;
501 int line_no = 1;
502 int c = getc(_stream);
503 while(c != EOF) {
504 c = get_line(c);
505 // Expecting only lines with "compile" command in inline replay file.
506 char* cmd = parse_string();
507 if (cmd == NULL || strcmp("compile", cmd) != 0) {
508 return NULL;
509 }
510 process_compile(CHECK_NULL);
511 if (had_error()) {
512 tty->print_cr("Error while parsing line %d: %s\n", line_no, _error_message);
513 tty->print_cr("%s", _buffer);
514 return NULL;
515 }
516 if (_ci_inline_records != NULL && _ci_inline_records->length() > 0) {
517 // Found inlining record for the requested method.
518 return _ci_inline_records;
519 }
520 line_no++;
521 }
522 return NULL;
523 }
524
525 // compile <klass> <name> <signature> <entry_bci> <comp_level> inline <count> <depth> <bci> <klass> <name> <signature> ...
526 void process_compile(TRAPS) {
527 Method* method = parse_method(CHECK);
528 if (had_error()) return;
529 int entry_bci = parse_int("entry_bci");
530 const char* comp_level_label = "comp_level";
531 int comp_level = parse_int(comp_level_label);
532 // old version w/o comp_level
533 if (had_error() && (error_message() == comp_level_label)) {
534 // use highest available tier
535 if (TieredCompilation) {
536 comp_level = TieredStopAtLevel;
537 } else {
538 comp_level = CompLevel_highest_tier;
539 }
540 }
541 if (!is_valid_comp_level(comp_level)) {
542 return;
543 }
544 if (_imethod != NULL) {
545 // Replay Inlining
546 if (entry_bci != _entry_bci || comp_level != _comp_level) {
547 return;
548 }
549 const char* iklass_name = _imethod->method_holder()->name()->as_utf8();
550 const char* imethod_name = _imethod->name()->as_utf8();
551 const char* isignature = _imethod->signature()->as_utf8();
552 const char* klass_name = method->method_holder()->name()->as_utf8();
553 const char* method_name = method->name()->as_utf8();
554 const char* signature = method->signature()->as_utf8();
555 if (strcmp(iklass_name, klass_name) != 0 ||
556 strcmp(imethod_name, method_name) != 0 ||
557 strcmp(isignature, signature) != 0) {
558 return;
559 }
560 }
561 int inline_count = 0;
562 if (parse_tag_and_count("inline", inline_count)) {
563 // Record inlining data
564 _ci_inline_records = new GrowableArray<ciInlineRecord*>();
565 for (int i = 0; i < inline_count; i++) {
566 int depth = parse_int("inline_depth");
567 int bci = parse_int("inline_bci");
568 if (had_error()) {
569 break;
570 }
571 Method* inl_method = parse_method(CHECK);
572 if (had_error()) {
573 break;
574 }
575 new_ciInlineRecord(inl_method, bci, depth);
576 }
577 }
578 if (_imethod != NULL) {
579 return; // Replay Inlining
580 }
581 InstanceKlass* ik = method->method_holder();
582 ik->initialize(THREAD);
583 if (HAS_PENDING_EXCEPTION) {
584 oop throwable = PENDING_EXCEPTION;
585 java_lang_Throwable::print(throwable, tty);
586 tty->cr();
587 if (ReplayIgnoreInitErrors) {
588 CLEAR_PENDING_EXCEPTION;
589 ik->set_init_state(InstanceKlass::fully_initialized);
590 } else {
591 return;
592 }
593 }
594 // Make sure the existence of a prior compile doesn't stop this one
595 CompiledMethod* nm = (entry_bci != InvocationEntryBci) ? method->lookup_osr_nmethod_for(entry_bci, comp_level, true) : method->code();
596 if (nm != NULL) {
597 nm->make_not_entrant();
598 }
599 replay_state = this;
600 CompileBroker::compile_method(method, entry_bci, comp_level,
601 methodHandle(), 0, CompileTask::Reason_Replay, THREAD);
602 replay_state = NULL;
603 reset();
604 }
605
606 // ciMethod <klass> <name> <signature> <invocation_counter> <backedge_counter> <interpreter_invocation_count> <interpreter_throwout_count> <instructions_size>
607 //
608 //
609 void process_ciMethod(TRAPS) {
610 Method* method = parse_method(CHECK);
611 if (had_error()) return;
612 ciMethodRecord* rec = new_ciMethod(method);
613 rec->_invocation_counter = parse_int("invocation_counter");
614 rec->_backedge_counter = parse_int("backedge_counter");
615 rec->_interpreter_invocation_count = parse_int("interpreter_invocation_count");
616 rec->_interpreter_throwout_count = parse_int("interpreter_throwout_count");
617 rec->_instructions_size = parse_int("instructions_size");
618 }
619
620 // ciMethodData <klass> <name> <signature> <state> <current mileage> orig <length> # # ... data <length> # # ... oops <length> # ... methods <length>
621 void process_ciMethodData(TRAPS) {
622 Method* method = parse_method(CHECK);
623 if (had_error()) return;
624 /* just copied from Method, to build interpret data*/
625
626 // To be properly initialized, some profiling in the MDO needs the
627 // method to be rewritten (number of arguments at a call for
628 // instance)
629 method->method_holder()->link_class(CHECK);
630 // methodOopDesc::build_interpreter_method_data(method, CHECK);
631 {
632 // Grab a lock here to prevent multiple
633 // MethodData*s from being created.
634 MutexLocker ml(MethodData_lock, THREAD);
635 if (method->method_data() == NULL) {
636 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
637 MethodData* method_data = MethodData::allocate(loader_data, method, CHECK);
638 method->set_method_data(method_data);
639 }
640 }
641
642 // collect and record all the needed information for later
643 ciMethodDataRecord* rec = new_ciMethodData(method);
644 rec->_state = parse_int("state");
645 rec->_current_mileage = parse_int("current_mileage");
646
647 rec->_orig_data = parse_data("orig", rec->_orig_data_length);
648 if (rec->_orig_data == NULL) {
649 return;
650 }
651 rec->_data = parse_intptr_data("data", rec->_data_length);
652 if (rec->_data == NULL) {
653 return;
654 }
655 if (!parse_tag_and_count("oops", rec->_classes_length)) {
656 return;
657 }
658 rec->_classes = NEW_RESOURCE_ARRAY(Klass*, rec->_classes_length);
659 rec->_classes_offsets = NEW_RESOURCE_ARRAY(int, rec->_classes_length);
660 for (int i = 0; i < rec->_classes_length; i++) {
661 int offset = parse_int("offset");
662 if (had_error()) {
663 return;
664 }
665 Klass* k = parse_klass(CHECK);
666 rec->_classes_offsets[i] = offset;
667 rec->_classes[i] = k;
668 }
669
670 if (!parse_tag_and_count("methods", rec->_methods_length)) {
671 return;
672 }
673 rec->_methods = NEW_RESOURCE_ARRAY(Method*, rec->_methods_length);
674 rec->_methods_offsets = NEW_RESOURCE_ARRAY(int, rec->_methods_length);
675 for (int i = 0; i < rec->_methods_length; i++) {
676 int offset = parse_int("offset");
677 if (had_error()) {
678 return;
679 }
680 Method* m = parse_method(CHECK);
681 rec->_methods_offsets[i] = offset;
682 rec->_methods[i] = m;
683 }
684 }
685
686 // instanceKlass <name>
687 //
688 // Loads and initializes the klass 'name'. This can be used to
689 // create particular class loading environments
690 void process_instanceKlass(TRAPS) {
691 // just load the referenced class
692 Klass* k = parse_klass(CHECK);
693 }
694
695 // ciInstanceKlass <name> <is_linked> <is_initialized> <length> tag # # # ...
696 //
697 // Load the klass 'name' and link or initialize it. Verify that the
698 // constant pool is the same length as 'length' and make sure the
699 // constant pool tags are in the same state.
700 void process_ciInstanceKlass(TRAPS) {
701 InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
702 if (k == NULL) {
703 return;
704 }
705 int is_linked = parse_int("is_linked");
706 int is_initialized = parse_int("is_initialized");
707 int length = parse_int("length");
708 if (is_initialized) {
709 k->initialize(THREAD);
710 if (HAS_PENDING_EXCEPTION) {
711 oop throwable = PENDING_EXCEPTION;
712 java_lang_Throwable::print(throwable, tty);
713 tty->cr();
714 if (ReplayIgnoreInitErrors) {
715 CLEAR_PENDING_EXCEPTION;
716 k->set_init_state(InstanceKlass::fully_initialized);
717 } else {
718 return;
719 }
720 }
721 } else if (is_linked) {
722 k->link_class(CHECK);
723 }
724 ConstantPool* cp = k->constants();
725 if (length != cp->length()) {
726 report_error("constant pool length mismatch: wrong class files?");
727 return;
728 }
729
730 int parsed_two_word = 0;
731 for (int i = 1; i < length; i++) {
732 int tag = parse_int("tag");
733 if (had_error()) {
734 return;
735 }
736 switch (cp->tag_at(i).value()) {
737 case JVM_CONSTANT_UnresolvedClass: {
738 if (tag == JVM_CONSTANT_Class) {
739 tty->print_cr("Resolving klass %s at %d", cp->klass_name_at(i)->as_utf8(), i);
740 Klass* k = cp->klass_at(i, CHECK);
741 }
742 break;
743 }
744 case JVM_CONSTANT_Long:
745 case JVM_CONSTANT_Double:
746 parsed_two_word = i + 1;
747
748 case JVM_CONSTANT_ClassIndex:
749 case JVM_CONSTANT_StringIndex:
750 case JVM_CONSTANT_String:
751 case JVM_CONSTANT_UnresolvedClassInError:
752 case JVM_CONSTANT_Fieldref:
753 case JVM_CONSTANT_Methodref:
754 case JVM_CONSTANT_InterfaceMethodref:
755 case JVM_CONSTANT_NameAndType:
756 case JVM_CONSTANT_Utf8:
757 case JVM_CONSTANT_Integer:
758 case JVM_CONSTANT_Float:
759 case JVM_CONSTANT_MethodHandle:
760 case JVM_CONSTANT_MethodType:
761 case JVM_CONSTANT_Dynamic:
762 case JVM_CONSTANT_InvokeDynamic:
763 if (tag != cp->tag_at(i).value()) {
764 report_error("tag mismatch: wrong class files?");
765 return;
766 }
767 break;
768
769 case JVM_CONSTANT_Class:
770 if (tag == JVM_CONSTANT_Class) {
771 } else if (tag == JVM_CONSTANT_UnresolvedClass) {
772 tty->print_cr("Warning: entry was unresolved in the replay data");
773 } else {
774 report_error("Unexpected tag");
775 return;
776 }
777 break;
778
779 case 0:
780 if (parsed_two_word == i) continue;
781
782 default:
783 fatal("Unexpected tag: %d", cp->tag_at(i).value());
784 break;
785 }
786
787 }
788 }
789
790 // Initialize a class and fill in the value for a static field.
791 // This is useful when the compile was dependent on the value of
792 // static fields but it's impossible to properly rerun the static
793 // initiailizer.
794 void process_staticfield(TRAPS) {
795 InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
796
797 if (k == NULL || ReplaySuppressInitializers == 0 ||
798 (ReplaySuppressInitializers == 2 && k->class_loader() == NULL)) {
799 return;
800 }
801
802 assert(k->is_initialized(), "must be");
803
804 const char* field_name = parse_escaped_string();
805 const char* field_signature = parse_string();
806 fieldDescriptor fd;
807 Symbol* name = SymbolTable::lookup(field_name, (int)strlen(field_name), CHECK);
808 Symbol* sig = SymbolTable::lookup(field_signature, (int)strlen(field_signature), CHECK);
809 if (!k->find_local_field(name, sig, &fd) ||
810 !fd.is_static() ||
811 fd.has_initial_value()) {
812 report_error(field_name);
813 return;
814 }
815
816 oop java_mirror = k->java_mirror();
817 if (field_signature[0] == '[') {
818 int length = parse_int("array length");
819 oop value = NULL;
820
821 if (field_signature[1] == '[') {
822 // multi dimensional array
823 ArrayKlass* kelem = (ArrayKlass *)parse_klass(CHECK);
824 if (kelem == NULL) {
825 return;
826 }
827 int rank = 0;
828 while (field_signature[rank] == '[') {
829 rank++;
830 }
831 jint* dims = NEW_RESOURCE_ARRAY(jint, rank);
832 dims[0] = length;
833 for (int i = 1; i < rank; i++) {
834 dims[i] = 1; // These aren't relevant to the compiler
835 }
836 value = kelem->multi_allocate(rank, dims, CHECK);
837 } else {
838 if (strcmp(field_signature, "[B") == 0) {
839 value = oopFactory::new_byteArray(length, CHECK);
840 } else if (strcmp(field_signature, "[Z") == 0) {
841 value = oopFactory::new_boolArray(length, CHECK);
842 } else if (strcmp(field_signature, "[C") == 0) {
843 value = oopFactory::new_charArray(length, CHECK);
844 } else if (strcmp(field_signature, "[S") == 0) {
845 value = oopFactory::new_shortArray(length, CHECK);
846 } else if (strcmp(field_signature, "[F") == 0) {
847 value = oopFactory::new_floatArray(length, CHECK);
848 } else if (strcmp(field_signature, "[D") == 0) {
849 value = oopFactory::new_doubleArray(length, CHECK);
850 } else if (strcmp(field_signature, "[I") == 0) {
851 value = oopFactory::new_intArray(length, CHECK);
852 } else if (strcmp(field_signature, "[J") == 0) {
853 value = oopFactory::new_longArray(length, CHECK);
854 } else if (field_signature[0] == '[' && field_signature[1] == 'L') {
855 Klass* kelem = resolve_klass(field_signature + 1, CHECK);
856 value = oopFactory::new_objArray(kelem, length, CHECK);
857 } else {
858 report_error("unhandled array staticfield");
859 }
860 }
861 java_mirror->obj_field_put(fd.offset(), value);
862 } else {
863 const char* string_value = parse_escaped_string();
864 if (strcmp(field_signature, "I") == 0) {
865 int value = atoi(string_value);
866 java_mirror->int_field_put(fd.offset(), value);
867 } else if (strcmp(field_signature, "B") == 0) {
868 int value = atoi(string_value);
869 java_mirror->byte_field_put(fd.offset(), value);
870 } else if (strcmp(field_signature, "C") == 0) {
871 int value = atoi(string_value);
872 java_mirror->char_field_put(fd.offset(), value);
873 } else if (strcmp(field_signature, "S") == 0) {
874 int value = atoi(string_value);
875 java_mirror->short_field_put(fd.offset(), value);
876 } else if (strcmp(field_signature, "Z") == 0) {
877 int value = atoi(string_value);
878 java_mirror->bool_field_put(fd.offset(), value);
879 } else if (strcmp(field_signature, "J") == 0) {
880 jlong value;
881 if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
882 fprintf(stderr, "Error parsing long: %s\n", string_value);
883 return;
884 }
885 java_mirror->long_field_put(fd.offset(), value);
886 } else if (strcmp(field_signature, "F") == 0) {
887 float value = atof(string_value);
888 java_mirror->float_field_put(fd.offset(), value);
889 } else if (strcmp(field_signature, "D") == 0) {
890 double value = atof(string_value);
891 java_mirror->double_field_put(fd.offset(), value);
892 } else if (strcmp(field_signature, "Ljava/lang/String;") == 0) {
893 Handle value = java_lang_String::create_from_str(string_value, CHECK);
894 java_mirror->obj_field_put(fd.offset(), value());
895 } else if (field_signature[0] == 'L') {
896 Klass* k = resolve_klass(string_value, CHECK);
897 oop value = InstanceKlass::cast(k)->allocate_instance(CHECK);
898 java_mirror->obj_field_put(fd.offset(), value);
899 } else {
900 report_error("unhandled staticfield");
901 }
902 }
903 }
904
905 #if INCLUDE_JVMTI
906 void process_JvmtiExport(TRAPS) {
907 const char* field = parse_string();
908 bool value = parse_int("JvmtiExport flag") != 0;
909 if (strcmp(field, "can_access_local_variables") == 0) {
910 JvmtiExport::set_can_access_local_variables(value);
911 } else if (strcmp(field, "can_hotswap_or_post_breakpoint") == 0) {
912 JvmtiExport::set_can_hotswap_or_post_breakpoint(value);
913 } else if (strcmp(field, "can_post_on_exceptions") == 0) {
914 JvmtiExport::set_can_post_on_exceptions(value);
915 } else {
916 report_error("Unrecognized JvmtiExport directive");
917 }
918 }
919 #endif // INCLUDE_JVMTI
920
921 // Create and initialize a record for a ciMethod
922 ciMethodRecord* new_ciMethod(Method* method) {
923 ciMethodRecord* rec = NEW_RESOURCE_OBJ(ciMethodRecord);
924 rec->_klass_name = method->method_holder()->name()->as_utf8();
925 rec->_method_name = method->name()->as_utf8();
926 rec->_signature = method->signature()->as_utf8();
927 _ci_method_records.append(rec);
928 return rec;
929 }
930
931 // Lookup data for a ciMethod
932 ciMethodRecord* find_ciMethodRecord(Method* method) {
933 const char* klass_name = method->method_holder()->name()->as_utf8();
934 const char* method_name = method->name()->as_utf8();
935 const char* signature = method->signature()->as_utf8();
936 for (int i = 0; i < _ci_method_records.length(); i++) {
937 ciMethodRecord* rec = _ci_method_records.at(i);
938 if (strcmp(rec->_klass_name, klass_name) == 0 &&
939 strcmp(rec->_method_name, method_name) == 0 &&
940 strcmp(rec->_signature, signature) == 0) {
941 return rec;
942 }
943 }
944 return NULL;
945 }
946
947 // Create and initialize a record for a ciMethodData
948 ciMethodDataRecord* new_ciMethodData(Method* method) {
949 ciMethodDataRecord* rec = NEW_RESOURCE_OBJ(ciMethodDataRecord);
950 rec->_klass_name = method->method_holder()->name()->as_utf8();
951 rec->_method_name = method->name()->as_utf8();
952 rec->_signature = method->signature()->as_utf8();
953 _ci_method_data_records.append(rec);
954 return rec;
955 }
956
957 // Lookup data for a ciMethodData
958 ciMethodDataRecord* find_ciMethodDataRecord(Method* method) {
959 const char* klass_name = method->method_holder()->name()->as_utf8();
960 const char* method_name = method->name()->as_utf8();
961 const char* signature = method->signature()->as_utf8();
962 for (int i = 0; i < _ci_method_data_records.length(); i++) {
963 ciMethodDataRecord* rec = _ci_method_data_records.at(i);
964 if (strcmp(rec->_klass_name, klass_name) == 0 &&
965 strcmp(rec->_method_name, method_name) == 0 &&
966 strcmp(rec->_signature, signature) == 0) {
967 return rec;
968 }
969 }
970 return NULL;
971 }
972
973 // Create and initialize a record for a ciInlineRecord
974 ciInlineRecord* new_ciInlineRecord(Method* method, int bci, int depth) {
975 ciInlineRecord* rec = NEW_RESOURCE_OBJ(ciInlineRecord);
976 rec->_klass_name = method->method_holder()->name()->as_utf8();
977 rec->_method_name = method->name()->as_utf8();
978 rec->_signature = method->signature()->as_utf8();
979 rec->_inline_bci = bci;
980 rec->_inline_depth = depth;
981 _ci_inline_records->append(rec);
982 return rec;
983 }
984
985 // Lookup inlining data for a ciMethod
986 ciInlineRecord* find_ciInlineRecord(Method* method, int bci, int depth) {
987 if (_ci_inline_records != NULL) {
988 return find_ciInlineRecord(_ci_inline_records, method, bci, depth);
989 }
990 return NULL;
991 }
992
993 static ciInlineRecord* find_ciInlineRecord(GrowableArray<ciInlineRecord*>* records,
994 Method* method, int bci, int depth) {
995 if (records != NULL) {
996 const char* klass_name = method->method_holder()->name()->as_utf8();
997 const char* method_name = method->name()->as_utf8();
998 const char* signature = method->signature()->as_utf8();
999 for (int i = 0; i < records->length(); i++) {
1000 ciInlineRecord* rec = records->at(i);
1001 if ((rec->_inline_bci == bci) &&
1002 (rec->_inline_depth == depth) &&
1003 (strcmp(rec->_klass_name, klass_name) == 0) &&
1004 (strcmp(rec->_method_name, method_name) == 0) &&
1005 (strcmp(rec->_signature, signature) == 0)) {
1006 return rec;
1007 }
1008 }
1009 }
1010 return NULL;
1011 }
1012
1013 const char* error_message() {
1014 return _error_message;
1015 }
1016
1017 void reset() {
1018 _error_message = NULL;
1019 _ci_method_records.clear();
1020 _ci_method_data_records.clear();
1021 }
1022
1023 // Take an ascii string contain \u#### escapes and convert it to utf8
1024 // in place.
1025 static void unescape_string(char* value) {
1026 char* from = value;
1027 char* to = value;
1028 while (*from != '\0') {
1029 if (*from != '\\') {
1030 *from++ = *to++;
1031 } else {
1032 switch (from[1]) {
1033 case 'u': {
1034 from += 2;
1035 jchar value=0;
1036 for (int i=0; i<4; i++) {
1037 char c = *from++;
1038 switch (c) {
1039 case '0': case '1': case '2': case '3': case '4':
1040 case '5': case '6': case '7': case '8': case '9':
1041 value = (value << 4) + c - '0';
1042 break;
1043 case 'a': case 'b': case 'c':
1044 case 'd': case 'e': case 'f':
1045 value = (value << 4) + 10 + c - 'a';
1046 break;
1047 case 'A': case 'B': case 'C':
1048 case 'D': case 'E': case 'F':
1049 value = (value << 4) + 10 + c - 'A';
1050 break;
1051 default:
1052 ShouldNotReachHere();
1053 }
1054 }
1055 UNICODE::convert_to_utf8(&value, 1, to);
1056 to++;
1057 break;
1058 }
1059 case 't': *to++ = '\t'; from += 2; break;
1060 case 'n': *to++ = '\n'; from += 2; break;
1061 case 'r': *to++ = '\r'; from += 2; break;
1062 case 'f': *to++ = '\f'; from += 2; break;
1063 default:
1064 ShouldNotReachHere();
1065 }
1066 }
1067 }
1068 *from = *to;
1069 }
1070 };
1071
1072 void ciReplay::replay(TRAPS) {
1073 int exit_code = replay_impl(THREAD);
1074
1075 Threads::destroy_vm();
1076
1077 vm_exit(exit_code);
1078 }
1079
1080 void* ciReplay::load_inline_data(ciMethod* method, int entry_bci, int comp_level) {
1081 if (FLAG_IS_DEFAULT(InlineDataFile)) {
1082 tty->print_cr("ERROR: no inline replay data file specified (use -XX:InlineDataFile=inline_pid12345.txt).");
1083 return NULL;
1084 }
1085
1086 VM_ENTRY_MARK;
1087 // Load and parse the replay data
1088 CompileReplay rp(InlineDataFile, THREAD);
1089 if (!rp.can_replay()) {
1090 tty->print_cr("ciReplay: !rp.can_replay()");
1091 return NULL;
1092 }
1093 void* data = rp.process_inline(method, method->get_Method(), entry_bci, comp_level, THREAD);
1094 if (HAS_PENDING_EXCEPTION) {
1095 Handle throwable(THREAD, PENDING_EXCEPTION);
1096 CLEAR_PENDING_EXCEPTION;
1097 java_lang_Throwable::print_stack_trace(throwable, tty);
1098 tty->cr();
1099 return NULL;
1100 }
1101
1102 if (rp.had_error()) {
1103 tty->print_cr("ciReplay: Failed on %s", rp.error_message());
1104 return NULL;
1105 }
1106 return data;
1107 }
1108
1109 int ciReplay::replay_impl(TRAPS) {
1110 HandleMark hm;
1111 ResourceMark rm;
1112
1113 if (ReplaySuppressInitializers > 2) {
1114 // ReplaySuppressInitializers > 2 means that we want to allow
1115 // normal VM bootstrap but once we get into the replay itself
1116 // don't allow any intializers to be run.
1117 ReplaySuppressInitializers = 1;
1118 }
1119
1120 if (FLAG_IS_DEFAULT(ReplayDataFile)) {
1121 tty->print_cr("ERROR: no compiler replay data file specified (use -XX:ReplayDataFile=replay_pid12345.txt).");
1122 return 1;
1123 }
1124
1125 // Load and parse the replay data
1126 CompileReplay rp(ReplayDataFile, THREAD);
1127 int exit_code = 0;
1128 if (rp.can_replay()) {
1129 rp.process(THREAD);
1130 } else {
1131 exit_code = 1;
1132 return exit_code;
1133 }
1134
1135 if (HAS_PENDING_EXCEPTION) {
1136 Handle throwable(THREAD, PENDING_EXCEPTION);
1137 CLEAR_PENDING_EXCEPTION;
1138 java_lang_Throwable::print_stack_trace(throwable, tty);
1139 tty->cr();
1140 exit_code = 2;
1141 }
1142
1143 if (rp.had_error()) {
1144 tty->print_cr("Failed on %s", rp.error_message());
1145 exit_code = 1;
1146 }
1147 return exit_code;
1148 }
1149
1150 void ciReplay::initialize(ciMethodData* m) {
1151 if (replay_state == NULL) {
1152 return;
1153 }
1154
1155 ASSERT_IN_VM;
1156 ResourceMark rm;
1157
1158 Method* method = m->get_MethodData()->method();
1159 ciMethodDataRecord* rec = replay_state->find_ciMethodDataRecord(method);
1160 if (rec == NULL) {
1161 // This indicates some mismatch with the original environment and
1162 // the replay environment though it's not always enough to
1163 // interfere with reproducing a bug
1164 tty->print_cr("Warning: requesting ciMethodData record for method with no data: ");
1165 method->print_name(tty);
1166 tty->cr();
1167 } else {
1168 m->_state = rec->_state;
1169 m->_current_mileage = rec->_current_mileage;
1170 if (rec->_data_length != 0) {
1171 assert(m->_data_size + m->_extra_data_size == rec->_data_length * (int)sizeof(rec->_data[0]) ||
1172 m->_data_size == rec->_data_length * (int)sizeof(rec->_data[0]), "must agree");
1173
1174 // Write the correct ciObjects back into the profile data
1175 ciEnv* env = ciEnv::current();
1176 for (int i = 0; i < rec->_classes_length; i++) {
1177 Klass *k = rec->_classes[i];
1178 // In case this class pointer is is tagged, preserve the tag bits
1179 intptr_t status = 0;
1180 if (k != NULL) {
1181 status = ciTypeEntries::with_status(env->get_metadata(k)->as_klass(), rec->_data[rec->_classes_offsets[i]]);
1182 }
1183 rec->_data[rec->_classes_offsets[i]] = status;
1184 }
1185 for (int i = 0; i < rec->_methods_length; i++) {
1186 Method *m = rec->_methods[i];
1187 *(ciMetadata**)(rec->_data + rec->_methods_offsets[i]) =
1188 env->get_metadata(m);
1189 }
1190 // Copy the updated profile data into place as intptr_ts
1191 #ifdef _LP64
1192 Copy::conjoint_jlongs_atomic((jlong *)rec->_data, (jlong *)m->_data, rec->_data_length);
1193 #else
1194 Copy::conjoint_jints_atomic((jint *)rec->_data, (jint *)m->_data, rec->_data_length);
1195 #endif
1196 }
1197
1198 // copy in the original header
1199 Copy::conjoint_jbytes(rec->_orig_data, (char*)&m->_orig, rec->_orig_data_length);
1200 }
1201 }
1202
1203
1204 bool ciReplay::should_not_inline(ciMethod* method) {
1205 if (replay_state == NULL) {
1206 return false;
1207 }
1208 VM_ENTRY_MARK;
1209 // ciMethod without a record shouldn't be inlined.
1210 return replay_state->find_ciMethodRecord(method->get_Method()) == NULL;
1211 }
1212
1213 bool ciReplay::should_inline(void* data, ciMethod* method, int bci, int inline_depth) {
1214 if (data != NULL) {
1215 GrowableArray<ciInlineRecord*>* records = (GrowableArray<ciInlineRecord*>*)data;
1216 VM_ENTRY_MARK;
1217 // Inline record are ordered by bci and depth.
1218 return CompileReplay::find_ciInlineRecord(records, method->get_Method(), bci, inline_depth) != NULL;
1219 } else if (replay_state != NULL) {
1220 VM_ENTRY_MARK;
1221 // Inline record are ordered by bci and depth.
1222 return replay_state->find_ciInlineRecord(method->get_Method(), bci, inline_depth) != NULL;
1223 }
1224 return false;
1225 }
1226
1227 bool ciReplay::should_not_inline(void* data, ciMethod* method, int bci, int inline_depth) {
1228 if (data != NULL) {
1229 GrowableArray<ciInlineRecord*>* records = (GrowableArray<ciInlineRecord*>*)data;
1230 VM_ENTRY_MARK;
1231 // Inline record are ordered by bci and depth.
1232 return CompileReplay::find_ciInlineRecord(records, method->get_Method(), bci, inline_depth) == NULL;
1233 } else if (replay_state != NULL) {
1234 VM_ENTRY_MARK;
1235 // Inline record are ordered by bci and depth.
1236 return replay_state->find_ciInlineRecord(method->get_Method(), bci, inline_depth) == NULL;
1237 }
1238 return false;
1239 }
1240
1241 void ciReplay::initialize(ciMethod* m) {
1242 if (replay_state == NULL) {
1243 return;
1244 }
1245
1246 ASSERT_IN_VM;
1247 ResourceMark rm;
1248
1249 Method* method = m->get_Method();
1250 ciMethodRecord* rec = replay_state->find_ciMethodRecord(method);
1251 if (rec == NULL) {
1252 // This indicates some mismatch with the original environment and
1253 // the replay environment though it's not always enough to
1254 // interfere with reproducing a bug
1255 tty->print_cr("Warning: requesting ciMethod record for method with no data: ");
1256 method->print_name(tty);
1257 tty->cr();
1258 } else {
1259 EXCEPTION_CONTEXT;
1260 // m->_instructions_size = rec->_instructions_size;
1261 m->_instructions_size = -1;
1262 m->_interpreter_invocation_count = rec->_interpreter_invocation_count;
1263 m->_interpreter_throwout_count = rec->_interpreter_throwout_count;
1264 MethodCounters* mcs = method->get_method_counters(CHECK_AND_CLEAR);
1265 guarantee(mcs != NULL, "method counters allocation failed");
1266 mcs->invocation_counter()->_counter = rec->_invocation_counter;
1267 mcs->backedge_counter()->_counter = rec->_backedge_counter;
1268 }
1269 }
1270
1271 bool ciReplay::is_loaded(Method* method) {
1272 if (replay_state == NULL) {
1273 return true;
1274 }
1275
1276 ASSERT_IN_VM;
1277 ResourceMark rm;
1278
1279 ciMethodRecord* rec = replay_state->find_ciMethodRecord(method);
1280 return rec != NULL;
1281 }
1282 #endif // PRODUCT