hotspot/src/share/vm/interpreter/bytecodeStream.hpp
author stefank
Tue, 23 Nov 2010 13:22:55 -0800
changeset 7397 5b173b4ca846
parent 5702 201c5cde25bb
child 7913 dd096a83bdbb
permissions -rw-r--r--
6989984: Use standard include model for Hospot Summary: Replaced MakeDeps and the includeDB files with more standardized solutions. Reviewed-by: coleenp, kvn, kamg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
5702
jrose
parents: 5547 5693
diff changeset
     2
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    25
#ifndef SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    26
#define SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    28
#include "interpreter/bytecode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    29
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    30
#include "oops/methodOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    31
#ifdef TARGET_ARCH_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    32
# include "bytes_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    33
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    34
#ifdef TARGET_ARCH_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    35
# include "bytes_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    36
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    37
#ifdef TARGET_ARCH_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    38
# include "bytes_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    39
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// A BytecodeStream is used for fast iteration over the bytecodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// of a methodOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// Usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// BytecodeStream s(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// Bytecodes::Code c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// while ((c = s.next()) >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
//   ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// }
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    51
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// A RawBytecodeStream is a simple version of BytecodeStream.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// It is used ONLY when we know the bytecodes haven't been rewritten
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    54
// yet, such as in the rewriter or the verifier.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    56
// Here is the common base class for both RawBytecodeStream and BytecodeStream:
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    57
class BaseBytecodeStream: StackObj {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // stream buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  methodHandle    _method;                       // read from method directly
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // reading position
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  int             _bci;                          // bci if current bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  int             _next_bci;                     // bci of next bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  int             _end_bci;                      // bci after the current iteration interval
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  // last bytecode read
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    68
  Bytecodes::Code _raw_code;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  bool            _is_wide;
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    70
  bool            _is_raw;                       // false in 'cooked' BytecodeStream
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    71
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    72
  // Construction
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    73
  BaseBytecodeStream(methodHandle method) : _method(method) {
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    74
    set_interval(0, _method->code_size());
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    75
    _is_raw = false;
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    76
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // Iteration control
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  void set_interval(int beg_bci, int end_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    // iterate over the interval [beg_bci, end_bci)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    assert(0 <= beg_bci && beg_bci <= method()->code_size(), "illegal beg_bci");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    assert(0 <= end_bci && end_bci <= method()->code_size(), "illegal end_bci");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    // setup of iteration pointers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    _bci      = beg_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    _next_bci = beg_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    _end_bci  = end_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  void set_start   (int beg_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    set_interval(beg_bci, _method->code_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    93
  bool is_raw() const { return _is_raw; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    94
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    95
  // Stream attributes
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    96
  methodHandle    method() const                 { return _method; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    97
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    98
  int             bci() const                    { return _bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
    99
  int             next_bci() const               { return _next_bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   100
  int             end_bci() const                { return _end_bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   101
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   102
  Bytecodes::Code raw_code() const               { return _raw_code; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   103
  bool            is_wide() const                { return _is_wide; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   104
  int             instruction_size() const       { return (_next_bci - _bci); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   105
  bool            is_last_bytecode() const       { return _next_bci >= _end_bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   106
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   107
  address         bcp() const                    { return method()->code_base() + _bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   108
  Bytecode*       bytecode() const               { return Bytecode_at(bcp()); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   109
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   110
  // State changes
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   111
  void            set_next_bci(int bci)          { assert(0 <= bci && bci <= method()->code_size(), "illegal bci"); _next_bci = bci; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   112
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   113
  // Bytecode-specific attributes
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   114
  int             dest() const                   { return bci() + bytecode()->get_offset_s2(raw_code()); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   115
  int             dest_w() const                 { return bci() + bytecode()->get_offset_s4(raw_code()); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   116
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   117
  // One-byte indices.
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   118
  int             get_index_u1() const           { assert_raw_index_size(1); return *(jubyte*)(bcp()+1); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   119
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   120
 protected:
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   121
  void assert_raw_index_size(int size) const NOT_DEBUG_RETURN;
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   122
  void assert_raw_stream(bool want_raw) const NOT_DEBUG_RETURN;
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   123
};
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   124
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   125
class RawBytecodeStream: public BaseBytecodeStream {
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   126
 public:
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   127
  // Construction
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   128
  RawBytecodeStream(methodHandle method) : BaseBytecodeStream(method) {
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   129
    _is_raw = true;
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   130
  }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   131
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   132
 public:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // Iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  // Use raw_next() rather than next() for faster method reference
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  Bytecodes::Code raw_next() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    Bytecodes::Code code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    // set reading position
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    _bci = _next_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    assert(!is_last_bytecode(), "caller should check is_last_bytecode()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   141
    address bcp = this->bcp();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    code        = Bytecodes::code_or_bp_at(bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    // set next bytecode position
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    int l = Bytecodes::length_for(code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    if (l > 0 && (_bci + l) <= _end_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
      assert(code != Bytecodes::_wide && code != Bytecodes::_tableswitch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
             && code != Bytecodes::_lookupswitch, "can't be special bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
      _is_wide = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
      _next_bci += l;
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   151
      _raw_code = code;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
      return code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      return raw_next_special(code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  Bytecodes::Code raw_next_special(Bytecodes::Code code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   159
  // Unsigned indices, widening, with no swapping of bytes
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   160
  int             get_index() const          { return (is_wide()) ? get_index_u2_raw(bcp() + 2) : get_index_u1(); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   161
  // Get an unsigned 2-byte index, with no swapping of bytes.
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   162
  int             get_index_u2() const       { assert(!is_wide(), ""); return get_index_u2_raw(bcp() + 1);  }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 1
diff changeset
   163
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 1
diff changeset
   164
 private:
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   165
  int get_index_u2_raw(address p) const {
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   166
    assert_raw_index_size(2); assert_raw_stream(true);
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   167
    return Bytes::get_Java_u2(p);
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 1
diff changeset
   168
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
// In BytecodeStream, non-java bytecodes will be translated into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
// corresponding java bytecodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   174
class BytecodeStream: public BaseBytecodeStream {
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   175
  Bytecodes::Code _code;
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   176
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // Construction
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   179
  BytecodeStream(methodHandle method) : BaseBytecodeStream(method) { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // Iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  Bytecodes::Code next() {
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   183
    Bytecodes::Code raw_code, code;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    // set reading position
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    _bci = _next_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    if (is_last_bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
      // indicate end of bytecode stream
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   188
      raw_code = code = Bytecodes::_illegal;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
      // get bytecode
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   191
      address bcp = this->bcp();
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   192
      raw_code = Bytecodes::code_at(bcp);
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   193
      code = Bytecodes::java_code(raw_code);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
      // set next bytecode position
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
      // note that we cannot advance before having the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
      // tty bytecode otherwise the stepping is wrong!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
      // (carefull: length_for(...) must be used first!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
      int l = Bytecodes::length_for(code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
      if (l == 0) l = Bytecodes::length_at(bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
      _next_bci  += l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
      assert(_bci < _next_bci, "length must be > 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
      // set attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
      _is_wide      = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
      // check for special (uncommon) cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
      if (code == Bytecodes::_wide) {
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   207
        raw_code = (Bytecodes::Code)bcp[1];
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   208
        code = raw_code;  // wide BCs are always Java-normal
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
        _is_wide = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      assert(Bytecodes::is_java_code(code), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    }
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   213
    _raw_code = raw_code;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    _code = code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    return _code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  bool            is_active_breakpoint() const   { return Bytecodes::is_active_breakpoint_at(bcp()); }
5688
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   219
  Bytecodes::Code code() const                   { return _code; }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   220
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   221
  // Unsigned indices, widening
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   222
  int             get_index() const              { return is_wide() ? bytecode()->get_index_u2(raw_code(), true) : get_index_u1(); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   223
  // Get an unsigned 2-byte index, swapping the bytes if necessary.
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   224
  int             get_index_u2() const           { assert_raw_stream(false);
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   225
                                                   return bytecode()->get_index_u2(raw_code(), false); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   226
  // Get an unsigned 2-byte index in native order.
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   227
  int             get_index_u2_cpcache() const   { assert_raw_stream(false);
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   228
                                                   return bytecode()->get_index_u2_cpcache(raw_code()); }
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   229
  int             get_index_u4() const           { assert_raw_stream(false);
9052dc91ea67 6939207: refactor constant pool index processing
jrose
parents: 3261
diff changeset
   230
                                                   return bytecode()->get_index_u4(raw_code()); }
5693
3015c564fcbc 6956164: nightly regressions from 6939207
jrose
parents: 5688
diff changeset
   231
  bool            has_index_u4() const           { return bytecode()->has_index_u4(raw_code()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
   233
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
   234
#endif // SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP