1 /*
  2  * Copyright (c) 1997, 2021, 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 "classfile/javaClasses.inline.hpp"
 27 #include "interpreter/bytecodeHistogram.hpp"
 28 #include "interpreter/bytecodeTracer.hpp"
 29 #include "interpreter/bytecodes.hpp"
 30 #include "interpreter/interpreter.hpp"
 31 #include "interpreter/interpreterRuntime.hpp"
 32 #include "memory/resourceArea.hpp"
 33 #include "oops/constantPool.inline.hpp"
 34 #include "oops/methodData.hpp"
 35 #include "oops/method.hpp"
 36 #include "runtime/mutexLocker.hpp"
 37 #include "runtime/osThread.hpp"
 38 #include "runtime/timer.hpp"
 39 #include "utilities/align.hpp"
 40 
 41 
 42 // Standard closure for BytecodeTracer: prints the current bytecode
 43 // and its attributes using bytecode-specific information.
 44 
 45 class BytecodePrinter: public BytecodeClosure {
 46  private:
 47   // %%% This field is not GC-ed, and so can contain garbage
 48   // between critical sections.  Use only pointer-comparison
 49   // operations on the pointer, except within a critical section.
 50   // (Also, ensure that occasional false positives are benign.)
 51   Method* _current_method;
 52   bool      _is_wide;
 53   Bytecodes::Code _code;
 54   address   _next_pc;                // current decoding position
 55 
 56   void      align()                  { _next_pc = align_up(_next_pc, sizeof(jint)); }
 57   int       get_byte()               { return *(jbyte*) _next_pc++; }  // signed
 58   short     get_short()              { short i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; }
 59   int       get_int()                { int i=Bytes::get_Java_u4(_next_pc); _next_pc+=4; return i; }
 60 
 61   int       get_index_u1()           { return *(address)_next_pc++; }
 62   int       get_index_u2()           { int i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; }
 63   int       get_index_u1_cpcache()   { return get_index_u1() + ConstantPool::CPCACHE_INDEX_TAG; }
 64   int       get_index_u2_cpcache()   { int i=Bytes::get_native_u2(_next_pc); _next_pc+=2; return i + ConstantPool::CPCACHE_INDEX_TAG; }
 65   int       get_index_u4()           { int i=Bytes::get_native_u4(_next_pc); _next_pc+=4; return i; }
 66   int       get_index_special()      { return (is_wide()) ? get_index_u2() : get_index_u1(); }
 67   Method* method()                 { return _current_method; }
 68   bool      is_wide()                { return _is_wide; }
 69   Bytecodes::Code raw_code()         { return Bytecodes::Code(_code); }
 70 
 71 
 72   bool      check_index(int i, int& cp_index, outputStream* st = tty);
 73   bool      check_cp_cache_index(int i, int& cp_index, outputStream* st = tty);
 74   bool      check_obj_index(int i, int& cp_index, outputStream* st = tty);
 75   bool      check_invokedynamic_index(int i, int& cp_index, outputStream* st = tty);
 76   void      print_constant(int i, outputStream* st = tty);
 77   void      print_field_or_method(int i, outputStream* st = tty);
 78   void      print_field_or_method(int orig_i, int i, outputStream* st = tty);
 79   void      print_attributes(int bci, outputStream* st = tty);
 80   void      bytecode_epilog(int bci, outputStream* st = tty);
 81 
 82  public:
 83   BytecodePrinter() {
 84     _is_wide = false;
 85     _code = Bytecodes::_illegal;
 86   }
 87 
 88   // This method is called while executing the raw bytecodes, so none of
 89   // the adjustments that BytecodeStream performs applies.
 90   void trace(const methodHandle& method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
 91     ResourceMark rm;
 92     if (_current_method != method()) {
 93       // Note 1: This code will not work as expected with true MT/MP.
 94       //         Need an explicit lock or a different solution.
 95       // It is possible for this block to be skipped, if a garbage
 96       // _current_method pointer happens to have the same bits as
 97       // the incoming method.  We could lose a line of trace output.
 98       // This is acceptable in a debug-only feature.
 99       st->cr();
100       st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
101       method->print_name(st);
102       st->cr();
103       _current_method = method();
104     }
105     Bytecodes::Code code;
106     if (is_wide()) {
107       // bcp wasn't advanced if previous bytecode was _wide.
108       code = Bytecodes::code_at(method(), bcp+1);
109     } else {
110       code = Bytecodes::code_at(method(), bcp);
111     }
112     _code = code;
113      int bci = bcp - method->code_base();
114     st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
115     if (Verbose) {
116       st->print("%8d  %4d  " INTPTR_FORMAT " " INTPTR_FORMAT " %s",
117            BytecodeCounter::counter_value(), bci, tos, tos2, Bytecodes::name(code));
118     } else {
119       st->print("%8d  %4d  %s",
120            BytecodeCounter::counter_value(), bci, Bytecodes::name(code));
121     }
122     _next_pc = is_wide() ? bcp+2 : bcp+1;
123     print_attributes(bci);
124     // Set is_wide for the next one, since the caller of this doesn't skip
125     // the next bytecode.
126     _is_wide = (code == Bytecodes::_wide);
127     _code = Bytecodes::_illegal;
128   }
129 
130   // Used for Method*::print_codes().  The input bcp comes from
131   // BytecodeStream, which will skip wide bytecodes.
132   void trace(const methodHandle& method, address bcp, outputStream* st) {
133     _current_method = method();
134     ResourceMark rm;
135     Bytecodes::Code code = Bytecodes::code_at(method(), bcp);
136     // Set is_wide
137     _is_wide = (code == Bytecodes::_wide);
138     if (is_wide()) {
139       code = Bytecodes::code_at(method(), bcp+1);
140     }
141     _code = code;
142     int bci = bcp - method->code_base();
143     // Print bytecode index and name
144     if (is_wide()) {
145       st->print("%d %s_w", bci, Bytecodes::name(code));
146     } else {
147       st->print("%d %s", bci, Bytecodes::name(code));
148     }
149     _next_pc = is_wide() ? bcp+2 : bcp+1;
150     print_attributes(bci, st);
151     bytecode_epilog(bci, st);
152   }
153 };
154 
155 
156 // Implementation of BytecodeTracer
157 
158 // %%% This set_closure thing seems overly general, given that
159 // nobody uses it.  Also, if BytecodePrinter weren't hidden
160 // then Method* could use instances of it directly and it
161 // would be easier to remove races on _current_method and bcp.
162 // Since this is not product functionality, we can defer cleanup.
163 
164 BytecodeClosure* BytecodeTracer::_closure = NULL;
165 
166 static BytecodePrinter std_closure;
167 BytecodeClosure* BytecodeTracer::std_closure() {
168   return &::std_closure;
169 }
170 
171 
172 void BytecodeTracer::trace(const methodHandle& method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
173   if (TraceBytecodes && BytecodeCounter::counter_value() >= TraceBytecodesAt) {
174     ttyLocker ttyl;  // 5065316: keep the following output coherent
175     // The ttyLocker also prevents races between two threads
176     // trying to use the single instance of BytecodePrinter.
177     // Using the ttyLocker prevents the system from coming to
178     // a safepoint within this code, which is sensitive to Method*
179     // movement.
180     //
181     // There used to be a leaf mutex here, but the ttyLocker will
182     // work just as well, as long as the printing operations never block.
183     //
184     // We put the locker on the static trace method, not the
185     // virtual one, because the clients of this module go through
186     // the static method.
187     _closure->trace(method, bcp, tos, tos2, st);
188   }
189 }
190 
191 void BytecodeTracer::trace(const methodHandle& method, address bcp, outputStream* st) {
192   ttyLocker ttyl;  // 5065316: keep the following output coherent
193   _closure->trace(method, bcp, st);
194 }
195 
196 void print_symbol(Symbol* sym, outputStream* st) {
197   char buf[40];
198   int len = sym->utf8_length();
199   if (len >= (int)sizeof(buf)) {
200     st->print_cr(" %s...[%d]", sym->as_C_string(buf, sizeof(buf)), len);
201   } else {
202     st->print(" ");
203     sym->print_on(st); st->cr();
204   }
205 }
206 
207 void print_oop(oop value, outputStream* st) {
208   if (value == NULL) {
209     st->print_cr(" NULL");
210   } else if (java_lang_String::is_instance(value)) {
211     char buf[40];
212     int len = java_lang_String::utf8_length(value);
213     java_lang_String::as_utf8_string(value, buf, sizeof(buf));
214     if (len >= (int)sizeof(buf)) {
215       st->print_cr(" %s...[%d]", buf, len);
216     } else {
217       st->print_cr(" %s", buf);
218     }
219   } else {
220     st->print_cr(" " INTPTR_FORMAT, p2i((void *)value));
221   }
222 }
223 
224 bool BytecodePrinter::check_index(int i, int& cp_index, outputStream* st) {
225   ConstantPool* constants = method()->constants();
226   int ilimit = constants->length();
227   Bytecodes::Code code = raw_code();
228 
229   if (Bytecodes::uses_cp_cache(code)) {
230     bool okay = true;
231     switch (code) {
232     case Bytecodes::_fast_aldc:
233     case Bytecodes::_fast_aldc_w:
234       okay = check_obj_index(i, cp_index, st);
235       break;
236     case Bytecodes::_invokedynamic:
237       okay = check_invokedynamic_index(i, cp_index, st);
238       break;
239     default:
240       okay = check_cp_cache_index(i, cp_index, st);
241       break;
242     }
243     if (!okay) return false;
244   }
245 
246 
247   // check cp index
248   if (cp_index >= 0 && cp_index < ilimit) {
249     if (WizardMode)  st->print(" cp[%d]", cp_index);
250     return true;
251   }
252 
253   st->print_cr(" CP[%d] not in CP", cp_index);
254   return false;
255 }
256 
257 bool BytecodePrinter::check_cp_cache_index(int i, int& cp_index, outputStream* st) {
258   ConstantPool* constants = method()->constants();
259   int climit = 0;
260 
261   ConstantPoolCache* cache = constants->cache();
262   // If rewriter hasn't run, the index is the cp_index
263   if (cache == NULL) {
264     cp_index = i;
265     return true;
266   }
267   //climit = cache->length();  // %%% private!
268   size_t size = cache->size() * wordSize;
269   size -= sizeof(ConstantPoolCache);
270   size /= sizeof(ConstantPoolCacheEntry);
271   climit = (int) size;
272 
273 #ifdef ASSERT
274   {
275     const int CPCACHE_INDEX_TAG = ConstantPool::CPCACHE_INDEX_TAG;
276     if (i >= CPCACHE_INDEX_TAG && i < climit + CPCACHE_INDEX_TAG) {
277       i -= CPCACHE_INDEX_TAG;
278     } else {
279       st->print_cr(" CP[%d] missing bias?", i);
280       return false;
281     }
282   }
283 #endif //ASSERT
284   if (i >= 0 && i < climit) {
285     cp_index = cache->entry_at(i)->constant_pool_index();
286   } else {
287     st->print_cr("%d not in CP[*]?", i);
288       return false;
289     }
290   return true;
291   }
292 
293 
294 bool BytecodePrinter::check_obj_index(int i, int& cp_index, outputStream* st) {
295   ConstantPool* constants = method()->constants();
296   i -= ConstantPool::CPCACHE_INDEX_TAG;
297 
298   if (i >= 0 && i < constants->resolved_references()->length()) {
299      cp_index = constants->object_to_cp_index(i);
300      return true;
301   } else {
302     st->print_cr("%d not in OBJ[*]?", i);
303   return false;
304 }
305 }
306 
307 
308 bool BytecodePrinter::check_invokedynamic_index(int i, int& cp_index, outputStream* st) {
309   assert(ConstantPool::is_invokedynamic_index(i), "not secondary index?");
310   i = ConstantPool::decode_invokedynamic_index(i) + ConstantPool::CPCACHE_INDEX_TAG;
311 
312   return check_cp_cache_index(i, cp_index, st);
313 }
314 
315 void BytecodePrinter::print_constant(int i, outputStream* st) {
316   int orig_i = i;
317   if (!check_index(orig_i, i, st))  return;
318 
319   ConstantPool* constants = method()->constants();
320   constantTag tag = constants->tag_at(i);
321 
322   if (tag.is_int()) {
323     st->print_cr(" " INT32_FORMAT, constants->int_at(i));
324   } else if (tag.is_long()) {
325     st->print_cr(" " INT64_FORMAT, (int64_t)(constants->long_at(i)));
326   } else if (tag.is_float()) {
327     st->print_cr(" %f", constants->float_at(i));
328   } else if (tag.is_double()) {
329     st->print_cr(" %f", constants->double_at(i));
330   } else if (tag.is_string()) {
331     const char* string = constants->string_at_noresolve(i);
332     st->print_cr(" %s", string);
333   } else if (tag.is_klass()) {
334     st->print_cr(" %s", constants->resolved_klass_at(i)->external_name());
335   } else if (tag.is_unresolved_klass()) {
336     st->print_cr(" <unresolved klass at %d>", i);
337   } else if (tag.is_method_type()) {
338     int i2 = constants->method_type_index_at(i);
339     st->print(" <MethodType> %d", i2);
340     print_symbol(constants->symbol_at(i2), st);
341   } else if (tag.is_method_handle()) {
342     int kind = constants->method_handle_ref_kind_at(i);
343     int i2 = constants->method_handle_index_at(i);
344     st->print(" <MethodHandle of kind %d index at %d>", kind, i2);
345     print_field_or_method(-i, i2, st);
346   } else {
347     st->print_cr(" bad tag=%d at %d", tag.value(), i);
348   }
349 }
350 
351 void BytecodePrinter::print_field_or_method(int i, outputStream* st) {
352   int orig_i = i;
353   if (!check_index(orig_i, i, st))  return;
354   print_field_or_method(orig_i, i, st);
355 }
356 
357 void BytecodePrinter::print_field_or_method(int orig_i, int i, outputStream* st) {
358   ConstantPool* constants = method()->constants();
359   constantTag tag = constants->tag_at(i);
360 
361   bool has_klass = true;
362 
363   switch (tag.value()) {
364   case JVM_CONSTANT_InterfaceMethodref:
365   case JVM_CONSTANT_Methodref:
366   case JVM_CONSTANT_Fieldref:
367     break;
368   case JVM_CONSTANT_NameAndType:
369   case JVM_CONSTANT_Dynamic:
370   case JVM_CONSTANT_InvokeDynamic:
371     has_klass = false;
372     break;
373   default:
374     st->print_cr(" bad tag=%d at %d", tag.value(), i);
375     return;
376   }
377 
378   Symbol* name = constants->uncached_name_ref_at(i);
379   Symbol* signature = constants->uncached_signature_ref_at(i);
380   const char* sep = (tag.is_field() ? "/" : "");
381   if (has_klass) {
382     Symbol* klass = constants->klass_name_at(constants->uncached_klass_ref_index_at(i));
383     st->print_cr(" %d <%s.%s%s%s> ", i, klass->as_C_string(), name->as_C_string(), sep, signature->as_C_string());
384   } else {
385     if (tag.is_dynamic_constant() || tag.is_invoke_dynamic()) {
386       int bsm = constants->bootstrap_method_ref_index_at(i);
387       st->print(" bsm=%d", bsm);
388     }
389     st->print_cr(" %d <%s%s%s>", i, name->as_C_string(), sep, signature->as_C_string());
390   }
391 }
392 
393 
394 void BytecodePrinter::print_attributes(int bci, outputStream* st) {
395   // Show attributes of pre-rewritten codes
396   Bytecodes::Code code = Bytecodes::java_code(raw_code());
397   // If the code doesn't have any fields there's nothing to print.
398   // note this is ==1 because the tableswitch and lookupswitch are
399   // zero size (for some reason) and we want to print stuff out for them.
400   if (Bytecodes::length_for(code) == 1) {
401     st->cr();
402     return;
403   }
404 
405   switch(code) {
406     // Java specific bytecodes only matter.
407     case Bytecodes::_bipush:
408       st->print_cr(" " INT32_FORMAT, get_byte());
409       break;
410     case Bytecodes::_sipush:
411       st->print_cr(" " INT32_FORMAT, get_short());
412       break;
413     case Bytecodes::_ldc:
414       if (Bytecodes::uses_cp_cache(raw_code())) {
415         print_constant(get_index_u1_cpcache(), st);
416       } else {
417         print_constant(get_index_u1(), st);
418       }
419       break;
420 
421     case Bytecodes::_ldc_w:
422     case Bytecodes::_ldc2_w:
423       if (Bytecodes::uses_cp_cache(raw_code())) {
424         print_constant(get_index_u2_cpcache(), st);
425       } else {
426         print_constant(get_index_u2(), st);
427       }
428       break;
429 
430     case Bytecodes::_iload:
431     case Bytecodes::_lload:
432     case Bytecodes::_fload:
433     case Bytecodes::_dload:
434     case Bytecodes::_aload:
435     case Bytecodes::_istore:
436     case Bytecodes::_lstore:
437     case Bytecodes::_fstore:
438     case Bytecodes::_dstore:
439     case Bytecodes::_astore:
440       st->print_cr(" #%d", get_index_special());
441       break;
442 
443     case Bytecodes::_iinc:
444       { int index = get_index_special();
445         jint offset = is_wide() ? get_short(): get_byte();
446         st->print_cr(" #%d " INT32_FORMAT, index, offset);
447       }
448       break;
449 
450     case Bytecodes::_newarray: {
451         BasicType atype = (BasicType)get_index_u1();
452         const char* str = type2name(atype);
453         if (str == NULL || is_reference_type(atype)) {
454           assert(false, "Unidentified basic type");
455         }
456         st->print_cr(" %s", str);
457       }
458       break;
459     case Bytecodes::_anewarray: {
460         int klass_index = get_index_u2();
461         ConstantPool* constants = method()->constants();
462         Symbol* name = constants->klass_name_at(klass_index);
463         st->print_cr(" %s ", name->as_C_string());
464       }
465       break;
466     case Bytecodes::_multianewarray: {
467         int klass_index = get_index_u2();
468         int nof_dims = get_index_u1();
469         ConstantPool* constants = method()->constants();
470         Symbol* name = constants->klass_name_at(klass_index);
471         st->print_cr(" %s %d", name->as_C_string(), nof_dims);
472       }
473       break;
474 
475     case Bytecodes::_ifeq:
476     case Bytecodes::_ifnull:
477     case Bytecodes::_iflt:
478     case Bytecodes::_ifle:
479     case Bytecodes::_ifne:
480     case Bytecodes::_ifnonnull:
481     case Bytecodes::_ifgt:
482     case Bytecodes::_ifge:
483     case Bytecodes::_if_icmpeq:
484     case Bytecodes::_if_icmpne:
485     case Bytecodes::_if_icmplt:
486     case Bytecodes::_if_icmpgt:
487     case Bytecodes::_if_icmple:
488     case Bytecodes::_if_icmpge:
489     case Bytecodes::_if_acmpeq:
490     case Bytecodes::_if_acmpne:
491     case Bytecodes::_goto:
492     case Bytecodes::_jsr:
493       st->print_cr(" %d", bci + get_short());
494       break;
495 
496     case Bytecodes::_goto_w:
497     case Bytecodes::_jsr_w:
498       st->print_cr(" %d", bci + get_int());
499       break;
500 
501     case Bytecodes::_ret: st->print_cr(" %d", get_index_special()); break;
502 
503     case Bytecodes::_tableswitch:
504       { align();
505         int  default_dest = bci + get_int();
506         int  lo           = get_int();
507         int  hi           = get_int();
508         int  len          = hi - lo + 1;
509         jint* dest        = NEW_RESOURCE_ARRAY(jint, len);
510         for (int i = 0; i < len; i++) {
511           dest[i] = bci + get_int();
512         }
513         st->print(" %d " INT32_FORMAT " " INT32_FORMAT " ",
514                       default_dest, lo, hi);
515         const char *comma = "";
516         for (int ll = lo; ll <= hi; ll++) {
517           int idx = ll - lo;
518           st->print("%s %d:" INT32_FORMAT " (delta: %d)", comma, ll, dest[idx], dest[idx]-bci);
519           comma = ",";
520         }
521         st->cr();
522       }
523       break;
524     case Bytecodes::_lookupswitch:
525       { align();
526         int  default_dest = bci + get_int();
527         int  len          = get_int();
528         jint* key         = NEW_RESOURCE_ARRAY(jint, len);
529         jint* dest        = NEW_RESOURCE_ARRAY(jint, len);
530         for (int i = 0; i < len; i++) {
531           key [i] = get_int();
532           dest[i] = bci + get_int();
533         };
534         st->print(" %d %d ", default_dest, len);
535         const char *comma = "";
536         for (int ll = 0; ll < len; ll++)  {
537           st->print("%s " INT32_FORMAT ":" INT32_FORMAT, comma, key[ll], dest[ll]);
538           comma = ",";
539         }
540         st->cr();
541       }
542       break;
543 
544     case Bytecodes::_putstatic:
545     case Bytecodes::_getstatic:
546     case Bytecodes::_putfield:
547     case Bytecodes::_getfield:
548       print_field_or_method(get_index_u2_cpcache(), st);
549       break;
550 
551     case Bytecodes::_invokevirtual:
552     case Bytecodes::_invokespecial:
553     case Bytecodes::_invokestatic:
554       print_field_or_method(get_index_u2_cpcache(), st);
555       break;
556 
557     case Bytecodes::_invokeinterface:
558       { int i = get_index_u2_cpcache();
559         int n = get_index_u1();
560         get_byte();            // ignore zero byte
561         print_field_or_method(i, st);
562       }
563       break;
564 
565     case Bytecodes::_invokedynamic:
566       print_field_or_method(get_index_u4(), st);
567       break;
568 
569     case Bytecodes::_new:
570     case Bytecodes::_checkcast:
571     case Bytecodes::_instanceof:
572       { int i = get_index_u2();
573         ConstantPool* constants = method()->constants();
574         Symbol* name = constants->klass_name_at(i);
575         st->print_cr(" %d <%s>", i, name->as_C_string());
576       }
577       break;
578 
579     case Bytecodes::_wide:
580       // length is zero not one, but printed with no more info.
581       break;
582 
583     default:
584       ShouldNotReachHere();
585       break;
586   }
587 }
588 
589 
590 void BytecodePrinter::bytecode_epilog(int bci, outputStream* st) {
591   MethodData* mdo = method()->method_data();
592   if (mdo != NULL) {
593     ProfileData* data = mdo->bci_to_data(bci);
594     if (data != NULL) {
595       st->print("  %d", mdo->dp_to_di(data->dp()));
596       st->fill_to(6);
597       data->print_data_on(st, mdo);
598     }
599   }
600 }