bytecodeStream.hpp 9.0 KB
Newer Older
D
duke 已提交
1
/*
V
vkempik 已提交
2
 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28 29
#ifndef SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
#define SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP

#include "interpreter/bytecode.hpp"
#include "memory/allocation.hpp"
30 31
#include "oops/method.hpp"
#include "runtime/handles.inline.hpp"
32 33 34 35 36 37 38 39 40
#ifdef TARGET_ARCH_x86
# include "bytes_x86.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "bytes_sparc.hpp"
#endif
#ifdef TARGET_ARCH_zero
# include "bytes_zero.hpp"
#endif
41 42 43 44 45 46
#ifdef TARGET_ARCH_arm
# include "bytes_arm.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "bytes_ppc.hpp"
#endif
47

D
duke 已提交
48
// A BytecodeStream is used for fast iteration over the bytecodes
49
// of a Method*.
D
duke 已提交
50 51 52 53 54 55 56 57
//
// Usage:
//
// BytecodeStream s(method);
// Bytecodes::Code c;
// while ((c = s.next()) >= 0) {
//   ...
// }
58

D
duke 已提交
59 60
// A RawBytecodeStream is a simple version of BytecodeStream.
// It is used ONLY when we know the bytecodes haven't been rewritten
61
// yet, such as in the rewriter or the verifier.
D
duke 已提交
62

63 64
// Here is the common base class for both RawBytecodeStream and BytecodeStream:
class BaseBytecodeStream: StackObj {
D
duke 已提交
65 66 67 68 69 70 71 72 73 74
 protected:
  // stream buffer
  methodHandle    _method;                       // read from method directly

  // reading position
  int             _bci;                          // bci if current bytecode
  int             _next_bci;                     // bci of next bytecode
  int             _end_bci;                      // bci after the current iteration interval

  // last bytecode read
75
  Bytecodes::Code _raw_code;
D
duke 已提交
76
  bool            _is_wide;
77
  bool            _is_raw;                       // false in 'cooked' BytecodeStream
D
duke 已提交
78 79

  // Construction
80
  BaseBytecodeStream(methodHandle method) : _method(method) {
D
duke 已提交
81
    set_interval(0, _method->code_size());
82
    _is_raw = false;
D
duke 已提交
83 84
  }

85
 public:
D
duke 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98 99
  // Iteration control
  void set_interval(int beg_bci, int end_bci) {
    // iterate over the interval [beg_bci, end_bci)
    assert(0 <= beg_bci && beg_bci <= method()->code_size(), "illegal beg_bci");
    assert(0 <= end_bci && end_bci <= method()->code_size(), "illegal end_bci");
    // setup of iteration pointers
    _bci      = beg_bci;
    _next_bci = beg_bci;
    _end_bci  = end_bci;
  }
  void set_start   (int beg_bci) {
    set_interval(beg_bci, _method->code_size());
  }

100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
  bool is_raw() const { return _is_raw; }

  // Stream attributes
  methodHandle    method() const                 { return _method; }

  int             bci() const                    { return _bci; }
  int             next_bci() const               { return _next_bci; }
  int             end_bci() const                { return _end_bci; }

  Bytecodes::Code raw_code() const               { return _raw_code; }
  bool            is_wide() const                { return _is_wide; }
  int             instruction_size() const       { return (_next_bci - _bci); }
  bool            is_last_bytecode() const       { return _next_bci >= _end_bci; }

  address         bcp() const                    { return method()->code_base() + _bci; }
115
  Bytecode        bytecode() const               { return Bytecode(_method(), bcp()); }
116 117 118 119 120

  // State changes
  void            set_next_bci(int bci)          { assert(0 <= bci && bci <= method()->code_size(), "illegal bci"); _next_bci = bci; }

  // Bytecode-specific attributes
121 122
  int             dest() const                   { return bci() + bytecode().get_offset_s2(raw_code()); }
  int             dest_w() const                 { return bci() + bytecode().get_offset_s4(raw_code()); }
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

  // One-byte indices.
  int             get_index_u1() const           { assert_raw_index_size(1); return *(jubyte*)(bcp()+1); }

 protected:
  void assert_raw_index_size(int size) const NOT_DEBUG_RETURN;
  void assert_raw_stream(bool want_raw) const NOT_DEBUG_RETURN;
};

class RawBytecodeStream: public BaseBytecodeStream {
 public:
  // Construction
  RawBytecodeStream(methodHandle method) : BaseBytecodeStream(method) {
    _is_raw = true;
  }

 public:
D
duke 已提交
140 141 142 143 144 145 146 147
  // Iteration
  // Use raw_next() rather than next() for faster method reference
  Bytecodes::Code raw_next() {
    Bytecodes::Code code;
    // set reading position
    _bci = _next_bci;
    assert(!is_last_bytecode(), "caller should check is_last_bytecode()");

148
    address bcp = this->bcp();
D
duke 已提交
149 150 151
    code        = Bytecodes::code_or_bp_at(bcp);

    // set next bytecode position
V
vkempik 已提交
152 153
    int len = Bytecodes::length_for(code);
    if (len > 0 && (_bci <= _end_bci - len)) {
D
duke 已提交
154 155 156
      assert(code != Bytecodes::_wide && code != Bytecodes::_tableswitch
             && code != Bytecodes::_lookupswitch, "can't be special bytecode");
      _is_wide = false;
V
vkempik 已提交
157 158 159 160
      _next_bci += len;
      if (_next_bci <= _bci) { // Check for integer overflow
        code = Bytecodes::_illegal;
      }
161
      _raw_code = code;
D
duke 已提交
162 163 164 165 166 167 168
      return code;
    } else {
      return raw_next_special(code);
    }
  }
  Bytecodes::Code raw_next_special(Bytecodes::Code code);

169 170 171 172
  // Unsigned indices, widening, with no swapping of bytes
  int             get_index() const          { return (is_wide()) ? get_index_u2_raw(bcp() + 2) : get_index_u1(); }
  // Get an unsigned 2-byte index, with no swapping of bytes.
  int             get_index_u2() const       { assert(!is_wide(), ""); return get_index_u2_raw(bcp() + 1);  }
173 174

 private:
175 176 177
  int get_index_u2_raw(address p) const {
    assert_raw_index_size(2); assert_raw_stream(true);
    return Bytes::get_Java_u2(p);
178
  }
D
duke 已提交
179 180 181 182 183
};

// In BytecodeStream, non-java bytecodes will be translated into the
// corresponding java bytecodes.

184 185 186
class BytecodeStream: public BaseBytecodeStream {
  Bytecodes::Code _code;

D
duke 已提交
187 188
 public:
  // Construction
189
  BytecodeStream(methodHandle method) : BaseBytecodeStream(method) { }
D
duke 已提交
190 191 192

  // Iteration
  Bytecodes::Code next() {
193
    Bytecodes::Code raw_code, code;
D
duke 已提交
194 195 196 197
    // set reading position
    _bci = _next_bci;
    if (is_last_bytecode()) {
      // indicate end of bytecode stream
198
      raw_code = code = Bytecodes::_illegal;
D
duke 已提交
199 200
    } else {
      // get bytecode
201
      address bcp = this->bcp();
202
      raw_code = Bytecodes::code_at(_method(), bcp);
203
      code = Bytecodes::java_code(raw_code);
D
duke 已提交
204 205 206 207 208
      // set next bytecode position
      //
      // note that we cannot advance before having the
      // tty bytecode otherwise the stepping is wrong!
      // (carefull: length_for(...) must be used first!)
V
vkempik 已提交
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
      int len = Bytecodes::length_for(code);
      if (len == 0) len = Bytecodes::length_at(_method(), bcp);
      if (len <= 0 || (_bci > _end_bci - len) || (_bci - len >= _next_bci)) {
        raw_code = code = Bytecodes::_illegal;
      } else {
        _next_bci  += len;
        assert(_bci < _next_bci, "length must be > 0");
        // set attributes
        _is_wide      = false;
        // check for special (uncommon) cases
        if (code == Bytecodes::_wide) {
          raw_code = (Bytecodes::Code)bcp[1];
          code = raw_code;  // wide BCs are always Java-normal
          _is_wide = true;
        }
        assert(Bytecodes::is_java_code(code), "sanity check");
D
duke 已提交
225 226
      }
    }
227
    _raw_code = raw_code;
D
duke 已提交
228 229 230 231 232
    _code = code;
    return _code;
  }

  bool            is_active_breakpoint() const   { return Bytecodes::is_active_breakpoint_at(bcp()); }
233 234 235
  Bytecodes::Code code() const                   { return _code; }

  // Unsigned indices, widening
236
  int             get_index() const              { return is_wide() ? bytecode().get_index_u2(raw_code(), true) : get_index_u1(); }
237 238
  // Get an unsigned 2-byte index, swapping the bytes if necessary.
  int             get_index_u2() const           { assert_raw_stream(false);
239
                                                   return bytecode().get_index_u2(raw_code(), false); }
240 241
  // Get an unsigned 2-byte index in native order.
  int             get_index_u2_cpcache() const   { assert_raw_stream(false);
242
                                                   return bytecode().get_index_u2_cpcache(raw_code()); }
243
  int             get_index_u4() const           { assert_raw_stream(false);
244 245
                                                   return bytecode().get_index_u4(raw_code()); }
  bool            has_index_u4() const           { return bytecode().has_index_u4(raw_code()); }
D
duke 已提交
246
};
247 248

#endif // SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP