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 #ifndef SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
  26 #define SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
  27 
  28 #include "interpreter/bytecode.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "oops/method.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 #ifdef TARGET_ARCH_x86
  33 # include "bytes_x86.hpp"
  34 #endif
  35 #ifdef TARGET_ARCH_sparc
  36 # include "bytes_sparc.hpp"
  37 #endif
  38 #ifdef TARGET_ARCH_zero
  39 # include "bytes_zero.hpp"
  40 #endif
  41 #ifdef TARGET_ARCH_arm
  42 # include "bytes_arm.hpp"
  43 #endif
  44 #ifdef TARGET_ARCH_ppc
  45 # include "bytes_ppc.hpp"
  46 #endif



  47 
  48 // A BytecodeStream is used for fast iteration over the bytecodes
  49 // of a Method*.
  50 //
  51 // Usage:
  52 //
  53 // BytecodeStream s(method);
  54 // Bytecodes::Code c;
  55 // while ((c = s.next()) >= 0) {
  56 //   ...
  57 // }
  58 
  59 // A RawBytecodeStream is a simple version of BytecodeStream.
  60 // It is used ONLY when we know the bytecodes haven't been rewritten
  61 // yet, such as in the rewriter or the verifier.
  62 
  63 // Here is the common base class for both RawBytecodeStream and BytecodeStream:
  64 class BaseBytecodeStream: StackObj {
  65  protected:
  66   // stream buffer
  67   methodHandle    _method;                       // read from method directly
  68 
  69   // reading position
  70   int             _bci;                          // bci if current bytecode
  71   int             _next_bci;                     // bci of next bytecode
  72   int             _end_bci;                      // bci after the current iteration interval
  73 
  74   // last bytecode read
  75   Bytecodes::Code _raw_code;
  76   bool            _is_wide;
  77   bool            _is_raw;                       // false in 'cooked' BytecodeStream
  78 
  79   // Construction
  80   BaseBytecodeStream(methodHandle method) : _method(method) {
  81     set_interval(0, _method->code_size());
  82     _is_raw = false;
  83   }
  84 
  85  public:
  86   // Iteration control
  87   void set_interval(int beg_bci, int end_bci) {
  88     // iterate over the interval [beg_bci, end_bci)
  89     assert(0 <= beg_bci && beg_bci <= method()->code_size(), "illegal beg_bci");
  90     assert(0 <= end_bci && end_bci <= method()->code_size(), "illegal end_bci");
  91     // setup of iteration pointers
  92     _bci      = beg_bci;
  93     _next_bci = beg_bci;
  94     _end_bci  = end_bci;
  95   }
  96   void set_start   (int beg_bci) {
  97     set_interval(beg_bci, _method->code_size());
  98   }
  99 
 100   bool is_raw() const { return _is_raw; }
 101 
 102   // Stream attributes
 103   methodHandle    method() const                 { return _method; }
 104 
 105   int             bci() const                    { return _bci; }
 106   int             next_bci() const               { return _next_bci; }
 107   int             end_bci() const                { return _end_bci; }
 108 
 109   Bytecodes::Code raw_code() const               { return _raw_code; }
 110   bool            is_wide() const                { return _is_wide; }
 111   int             instruction_size() const       { return (_next_bci - _bci); }
 112   bool            is_last_bytecode() const       { return _next_bci >= _end_bci; }
 113 
 114   address         bcp() const                    { return method()->code_base() + _bci; }
 115   Bytecode        bytecode() const               { return Bytecode(_method(), bcp()); }
 116 
 117   // State changes
 118   void            set_next_bci(int bci)          { assert(0 <= bci && bci <= method()->code_size(), "illegal bci"); _next_bci = bci; }
 119 
 120   // Bytecode-specific attributes
 121   int             dest() const                   { return bci() + bytecode().get_offset_s2(raw_code()); }
 122   int             dest_w() const                 { return bci() + bytecode().get_offset_s4(raw_code()); }
 123 
 124   // One-byte indices.
 125   int             get_index_u1() const           { assert_raw_index_size(1); return *(jubyte*)(bcp()+1); }
 126 
 127  protected:
 128   void assert_raw_index_size(int size) const NOT_DEBUG_RETURN;
 129   void assert_raw_stream(bool want_raw) const NOT_DEBUG_RETURN;
 130 };
 131 
 132 class RawBytecodeStream: public BaseBytecodeStream {
 133  public:
 134   // Construction
 135   RawBytecodeStream(methodHandle method) : BaseBytecodeStream(method) {
 136     _is_raw = true;
 137   }
 138 
 139  public:
 140   // Iteration
 141   // Use raw_next() rather than next() for faster method reference
 142   Bytecodes::Code raw_next() {
 143     Bytecodes::Code code;
 144     // set reading position
 145     _bci = _next_bci;
 146     assert(!is_last_bytecode(), "caller should check is_last_bytecode()");
 147 
 148     address bcp = this->bcp();
 149     code        = Bytecodes::code_or_bp_at(bcp);
 150 
 151     // set next bytecode position
 152     int len = Bytecodes::length_for(code);
 153     if (len > 0 && (_bci <= _end_bci - len)) {
 154       assert(code != Bytecodes::_wide && code != Bytecodes::_tableswitch
 155              && code != Bytecodes::_lookupswitch, "can't be special bytecode");
 156       _is_wide = false;
 157       _next_bci += len;
 158       if (_next_bci <= _bci) { // Check for integer overflow
 159         code = Bytecodes::_illegal;
 160       }
 161       _raw_code = code;
 162       return code;
 163     } else {
 164       return raw_next_special(code);
 165     }
 166   }
 167   Bytecodes::Code raw_next_special(Bytecodes::Code code);
 168 
 169   // Unsigned indices, widening, with no swapping of bytes
 170   int             get_index() const          { return (is_wide()) ? get_index_u2_raw(bcp() + 2) : get_index_u1(); }
 171   // Get an unsigned 2-byte index, with no swapping of bytes.
 172   int             get_index_u2() const       { assert(!is_wide(), ""); return get_index_u2_raw(bcp() + 1);  }
 173 
 174  private:
 175   int get_index_u2_raw(address p) const {
 176     assert_raw_index_size(2); assert_raw_stream(true);
 177     return Bytes::get_Java_u2(p);
 178   }
 179 };
 180 
 181 // In BytecodeStream, non-java bytecodes will be translated into the
 182 // corresponding java bytecodes.
 183 
 184 class BytecodeStream: public BaseBytecodeStream {
 185   Bytecodes::Code _code;
 186 
 187  public:
 188   // Construction
 189   BytecodeStream(methodHandle method) : BaseBytecodeStream(method) { }
 190 
 191   // Iteration
 192   Bytecodes::Code next() {
 193     Bytecodes::Code raw_code, code;
 194     // set reading position
 195     _bci = _next_bci;
 196     if (is_last_bytecode()) {
 197       // indicate end of bytecode stream
 198       raw_code = code = Bytecodes::_illegal;
 199     } else {
 200       // get bytecode
 201       address bcp = this->bcp();
 202       raw_code = Bytecodes::code_at(_method(), bcp);
 203       code = Bytecodes::java_code(raw_code);
 204       // set next bytecode position
 205       //
 206       // note that we cannot advance before having the
 207       // tty bytecode otherwise the stepping is wrong!
 208       // (carefull: length_for(...) must be used first!)
 209       int len = Bytecodes::length_for(code);
 210       if (len == 0) len = Bytecodes::length_at(_method(), bcp);
 211       if (len <= 0 || (_bci > _end_bci - len) || (_bci - len >= _next_bci)) {
 212         raw_code = code = Bytecodes::_illegal;
 213       } else {
 214         _next_bci  += len;
 215         assert(_bci < _next_bci, "length must be > 0");
 216         // set attributes
 217         _is_wide      = false;
 218         // check for special (uncommon) cases
 219         if (code == Bytecodes::_wide) {
 220           raw_code = (Bytecodes::Code)bcp[1];
 221           code = raw_code;  // wide BCs are always Java-normal
 222           _is_wide = true;
 223         }
 224         assert(Bytecodes::is_java_code(code), "sanity check");
 225       }
 226     }
 227     _raw_code = raw_code;
 228     _code = code;
 229     return _code;
 230   }
 231 
 232   bool            is_active_breakpoint() const   { return Bytecodes::is_active_breakpoint_at(bcp()); }
 233   Bytecodes::Code code() const                   { return _code; }
 234 
 235   // Unsigned indices, widening
 236   int             get_index() const              { return is_wide() ? bytecode().get_index_u2(raw_code(), true) : get_index_u1(); }
 237   // Get an unsigned 2-byte index, swapping the bytes if necessary.
 238   int             get_index_u2() const           { assert_raw_stream(false);
 239                                                    return bytecode().get_index_u2(raw_code(), false); }
 240   // Get an unsigned 2-byte index in native order.
 241   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                                                    return bytecode().get_index_u4(raw_code()); }
 245   bool            has_index_u4() const           { return bytecode().has_index_u4(raw_code()); }
 246 };
 247 
 248 #endif // SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP
--- EOF ---