1/*
2 * Copyright (c) 1997, 2016, 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/methodData.hpp"
34#include "oops/method.hpp"
35#include "runtime/mutexLocker.hpp"
36#include "runtime/timer.hpp"
37#include "utilities/align.hpp"
38
39
40// Standard closure for BytecodeTracer: prints the current bytecode
41// and its attributes using bytecode-specific information.
42
43class BytecodePrinter: public BytecodeClosure {
44 private:
45  // %%% This field is not GC-ed, and so can contain garbage
46  // between critical sections.  Use only pointer-comparison
47  // operations on the pointer, except within a critical section.
48  // (Also, ensure that occasional false positives are benign.)
49  Method* _current_method;
50  bool      _is_wide;
51  Bytecodes::Code _code;
52  address   _next_pc;                // current decoding position
53
54  void      align()                  { _next_pc = align_up(_next_pc, sizeof(jint)); }
55  int       get_byte()               { return *(jbyte*) _next_pc++; }  // signed
56  short     get_short()              { short i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; }
57  int       get_int()                { int i=Bytes::get_Java_u4(_next_pc); _next_pc+=4; return i; }
58
59  int       get_index_u1()           { return *(address)_next_pc++; }
60  int       get_index_u2()           { int i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; }
61  int       get_index_u1_cpcache()   { return get_index_u1() + ConstantPool::CPCACHE_INDEX_TAG; }
62  int       get_index_u2_cpcache()   { int i=Bytes::get_native_u2(_next_pc); _next_pc+=2; return i + ConstantPool::CPCACHE_INDEX_TAG; }
63  int       get_index_u4()           { int i=Bytes::get_native_u4(_next_pc); _next_pc+=4; return i; }
64  int       get_index_special()      { return (is_wide()) ? get_index_u2() : get_index_u1(); }
65  Method* method()                 { return _current_method; }
66  bool      is_wide()                { return _is_wide; }
67  Bytecodes::Code raw_code()         { return Bytecodes::Code(_code); }
68
69
70  bool      check_index(int i, int& cp_index, outputStream* st = tty);
71  bool      check_cp_cache_index(int i, int& cp_index, outputStream* st = tty);
72  bool      check_obj_index(int i, int& cp_index, outputStream* st = tty);
73  bool      check_invokedynamic_index(int i, int& cp_index, outputStream* st = tty);
74  void      print_constant(int i, outputStream* st = tty);
75  void      print_field_or_method(int i, outputStream* st = tty);
76  void      print_field_or_method(int orig_i, int i, outputStream* st = tty);
77  void      print_attributes(int bci, outputStream* st = tty);
78  void      bytecode_epilog(int bci, outputStream* st = tty);
79
80 public:
81  BytecodePrinter() {
82    _is_wide = false;
83    _code = Bytecodes::_illegal;
84  }
85
86  // This method is called while executing the raw bytecodes, so none of
87  // the adjustments that BytecodeStream performs applies.
88  void trace(const methodHandle& method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
89    ResourceMark rm;
90    if (_current_method != method()) {
91      // Note 1: This code will not work as expected with true MT/MP.
92      //         Need an explicit lock or a different solution.
93      // It is possible for this block to be skipped, if a garbage
94      // _current_method pointer happens to have the same bits as
95      // the incoming method.  We could lose a line of trace output.
96      // This is acceptable in a debug-only feature.
97      st->cr();
98      st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
99      method->print_name(st);
100      st->cr();
101      _current_method = method();
102    }
103    Bytecodes::Code code;
104    if (is_wide()) {
105      // bcp wasn't advanced if previous bytecode was _wide.
106      code = Bytecodes::code_at(method(), bcp+1);
107    } else {
108      code = Bytecodes::code_at(method(), bcp);
109    }
110    _code = code;
111     int bci = bcp - method->code_base();
112    st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
113    if (Verbose) {
114      st->print("%8d  %4d  " INTPTR_FORMAT " " INTPTR_FORMAT " %s",
115           BytecodeCounter::counter_value(), bci, tos, tos2, Bytecodes::name(code));
116    } else {
117      st->print("%8d  %4d  %s",
118           BytecodeCounter::counter_value(), bci, Bytecodes::name(code));
119    }
120    _next_pc = is_wide() ? bcp+2 : bcp+1;
121    print_attributes(bci);
122    // Set is_wide for the next one, since the caller of this doesn't skip
123    // the next bytecode.
124    _is_wide = (code == Bytecodes::_wide);
125    _code = Bytecodes::_illegal;
126  }
127
128  // Used for Method*::print_codes().  The input bcp comes from
129  // BytecodeStream, which will skip wide bytecodes.
130  void trace(const methodHandle& method, address bcp, outputStream* st) {
131    _current_method = method();
132    ResourceMark rm;
133    Bytecodes::Code code = Bytecodes::code_at(method(), bcp);
134    // Set is_wide
135    _is_wide = (code == Bytecodes::_wide);
136    if (is_wide()) {
137      code = Bytecodes::code_at(method(), bcp+1);
138    }
139    _code = code;
140    int bci = bcp - method->code_base();
141    // Print bytecode index and name
142    if (is_wide()) {
143      st->print("%d %s_w", bci, Bytecodes::name(code));
144    } else {
145      st->print("%d %s", bci, Bytecodes::name(code));
146    }
147    _next_pc = is_wide() ? bcp+2 : bcp+1;
148    print_attributes(bci, st);
149    bytecode_epilog(bci, st);
150  }
151};
152
153
154// Implementation of BytecodeTracer
155
156// %%% This set_closure thing seems overly general, given that
157// nobody uses it.  Also, if BytecodePrinter weren't hidden
158// then Method* could use instances of it directly and it
159// would be easier to remove races on _current_method and bcp.
160// Since this is not product functionality, we can defer cleanup.
161
162BytecodeClosure* BytecodeTracer::_closure = NULL;
163
164static BytecodePrinter std_closure;
165BytecodeClosure* BytecodeTracer::std_closure() {
166  return &::std_closure;
167}
168
169
170void BytecodeTracer::trace(const methodHandle& method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
171  if (TraceBytecodes && BytecodeCounter::counter_value() >= TraceBytecodesAt) {
172    ttyLocker ttyl;  // 5065316: keep the following output coherent
173    // The ttyLocker also prevents races between two threads
174    // trying to use the single instance of BytecodePrinter.
175    // Using the ttyLocker prevents the system from coming to
176    // a safepoint within this code, which is sensitive to Method*
177    // movement.
178    //
179    // There used to be a leaf mutex here, but the ttyLocker will
180    // work just as well, as long as the printing operations never block.
181    //
182    // We put the locker on the static trace method, not the
183    // virtual one, because the clients of this module go through
184    // the static method.
185    _closure->trace(method, bcp, tos, tos2, st);
186  }
187}
188
189void BytecodeTracer::trace(const methodHandle& method, address bcp, outputStream* st) {
190  ttyLocker ttyl;  // 5065316: keep the following output coherent
191  _closure->trace(method, bcp, st);
192}
193
194void print_symbol(Symbol* sym, outputStream* st) {
195  char buf[40];
196  int len = sym->utf8_length();
197  if (len >= (int)sizeof(buf)) {
198    st->print_cr(" %s...[%d]", sym->as_C_string(buf, sizeof(buf)), len);
199  } else {
200    st->print(" ");
201    sym->print_on(st); st->cr();
202  }
203}
204
205void print_oop(oop value, outputStream* st) {
206  if (value == NULL) {
207    st->print_cr(" NULL");
208  } else if (java_lang_String::is_instance(value)) {
209    char buf[40];
210    int len = java_lang_String::utf8_length(value);
211    java_lang_String::as_utf8_string(value, buf, sizeof(buf));
212    if (len >= (int)sizeof(buf)) {
213      st->print_cr(" %s...[%d]", buf, len);
214    } else {
215      st->print_cr(" %s", buf);
216    }
217  } else {
218    st->print_cr(" " INTPTR_FORMAT, p2i((void *)value));
219  }
220}
221
222bool BytecodePrinter::check_index(int i, int& cp_index, outputStream* st) {
223  ConstantPool* constants = method()->constants();
224  int ilimit = constants->length();
225  Bytecodes::Code code = raw_code();
226
227  ConstantPoolCache* cache = NULL;
228  if (Bytecodes::uses_cp_cache(code)) {
229    bool okay = true;
230    switch (code) {
231    case Bytecodes::_fast_aldc:
232    case Bytecodes::_fast_aldc_w:
233      okay = check_obj_index(i, cp_index, st);
234      break;
235    case Bytecodes::_invokedynamic:
236      okay = check_invokedynamic_index(i, cp_index, st);
237      break;
238    default:
239      okay = check_cp_cache_index(i, cp_index, st);
240      break;
241    }
242    if (!okay) return false;
243  }
244
245
246  // check cp index
247  if (cp_index >= 0 && cp_index < ilimit) {
248    if (WizardMode)  st->print(" cp[%d]", cp_index);
249    return true;
250  }
251
252  st->print_cr(" CP[%d] not in CP", cp_index);
253  return false;
254}
255
256bool BytecodePrinter::check_cp_cache_index(int i, int& cp_index, outputStream* st) {
257  ConstantPool* constants = method()->constants();
258  int ilimit = constants->length(), climit = 0;
259  Bytecodes::Code code = raw_code();
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
294bool 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
308bool BytecodePrinter::check_invokedynamic_index(int i, int& cp_index, outputStream* st) {
309  ConstantPool* constants = method()->constants();
310  assert(ConstantPool::is_invokedynamic_index(i), "not secondary index?");
311  i = ConstantPool::decode_invokedynamic_index(i) + ConstantPool::CPCACHE_INDEX_TAG;
312
313  return check_cp_cache_index(i, cp_index, st);
314}
315
316void BytecodePrinter::print_constant(int i, outputStream* st) {
317  int orig_i = i;
318  if (!check_index(orig_i, i, st))  return;
319
320  ConstantPool* constants = method()->constants();
321  constantTag tag = constants->tag_at(i);
322
323  if (tag.is_int()) {
324    st->print_cr(" " INT32_FORMAT, constants->int_at(i));
325  } else if (tag.is_long()) {
326    st->print_cr(" " INT64_FORMAT, (int64_t)(constants->long_at(i)));
327  } else if (tag.is_float()) {
328    st->print_cr(" %f", constants->float_at(i));
329  } else if (tag.is_double()) {
330    st->print_cr(" %f", constants->double_at(i));
331  } else if (tag.is_string()) {
332    const char* string = constants->string_at_noresolve(i);
333    st->print_cr(" %s", string);
334  } else if (tag.is_klass()) {
335    st->print_cr(" %s", constants->resolved_klass_at(i)->external_name());
336  } else if (tag.is_unresolved_klass()) {
337    st->print_cr(" <unresolved klass at %d>", i);
338  } else if (tag.is_method_type()) {
339    int i2 = constants->method_type_index_at(i);
340    st->print(" <MethodType> %d", i2);
341    print_symbol(constants->symbol_at(i2), st);
342  } else if (tag.is_method_handle()) {
343    int kind = constants->method_handle_ref_kind_at(i);
344    int i2 = constants->method_handle_index_at(i);
345    st->print(" <MethodHandle of kind %d index at %d>", kind, i2);
346    print_field_or_method(-i, i2, st);
347  } else {
348    st->print_cr(" bad tag=%d at %d", tag.value(), i);
349  }
350}
351
352void BytecodePrinter::print_field_or_method(int i, outputStream* st) {
353  int orig_i = i;
354  if (!check_index(orig_i, i, st))  return;
355  print_field_or_method(orig_i, i, st);
356}
357
358void BytecodePrinter::print_field_or_method(int orig_i, int i, outputStream* st) {
359  ConstantPool* constants = method()->constants();
360  constantTag tag = constants->tag_at(i);
361
362  bool has_klass = true;
363
364  switch (tag.value()) {
365  case JVM_CONSTANT_InterfaceMethodref:
366  case JVM_CONSTANT_Methodref:
367  case JVM_CONSTANT_Fieldref:
368    break;
369  case JVM_CONSTANT_NameAndType:
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_invoke_dynamic()) {
386      int bsm = constants->invoke_dynamic_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
394void 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 || atype == T_OBJECT || atype == T_ARRAY) {
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
590void 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}
601