hotspot/src/share/vm/classfile/stackMapFrame.hpp
author hseigel
Tue, 05 Aug 2014 09:11:35 -0400
changeset 25900 a41d63a62923
parent 17006 b9bfa72b7dda
child 27022 2db6fe33afc2
permissions -rw-r--r--
8046233: VerifyError on backward branch Summary: Remove check that causes the VerifyError Reviewed-by: dholmes, coleenp, acorn
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
25900
a41d63a62923 8046233: VerifyError on backward branch
hseigel
parents: 17006
diff changeset
     2
 * Copyright (c) 2003, 2014, 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: 1
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
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: 1
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: 5547
diff changeset
    25
#ifndef SHARE_VM_CLASSFILE_STACKMAPFRAME_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_CLASSFILE_STACKMAPFRAME_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "classfile/verificationType.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "classfile/verifier.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13476
diff changeset
    30
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "runtime/handles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "runtime/signature.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "utilities/exceptions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// A StackMapFrame represents one frame in the stack map attribute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    37
class TypeContext;
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    38
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  FLAG_THIS_UNINIT = 0x01
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class StackMapFrame : public ResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  int32_t _offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  // See comment in StackMapTable about _frame_count about why these
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  // fields are int32_t instead of u2.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  int32_t _locals_size;  // number of valid type elements in _locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  int32_t _stack_size;   // number of valid type elements in _stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    52
  int32_t _stack_mark;   // Records the size of the stack prior to an
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    53
                         // instruction modification, to allow rewinding
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    54
                         // when/if an error occurs.
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    55
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  int32_t _max_locals;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  int32_t _max_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  u1 _flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  VerificationType* _locals; // local variable type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  VerificationType* _stack;  // operand stack type array
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  ClassVerifier* _verifier;  // the verifier verifying this method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    65
  StackMapFrame(const StackMapFrame& cp) :
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    66
      _offset(cp._offset), _locals_size(cp._locals_size),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    67
      _stack_size(cp._stack_size), _stack_mark(cp._stack_mark),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    68
      _max_locals(cp._max_locals), _max_stack(cp._max_stack),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    69
      _flags(cp._flags) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    70
    _locals = NEW_RESOURCE_ARRAY(VerificationType, _max_locals);
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    71
    for (int i = 0; i < _max_locals; ++i) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    72
      if (i < _locals_size) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    73
        _locals[i] = cp._locals[i];
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    74
      } else {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    75
        _locals[i] = VerificationType::bogus_type();
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    76
      }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    77
    }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    78
    int ss = MAX2(_stack_size, _stack_mark);
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    79
    _stack = NEW_RESOURCE_ARRAY(VerificationType, _max_stack);
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    80
    for (int i = 0; i < _max_stack; ++i) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    81
      if (i < ss) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    82
        _stack[i] = cp._stack[i];
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    83
      } else {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    84
        _stack[i] = VerificationType::bogus_type();
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    85
      }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    86
    }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    87
    _verifier = NULL;
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    88
  }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
    89
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // constructors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // This constructor is used by the type checker to allocate frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // in type state, which have _max_locals and _max_stack array elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // in _locals and _stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* verifier);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // This constructor is used to initialize stackmap frames in stackmap table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // which have _locals_size and _stack_size array elements in _locals and _stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  StackMapFrame(int32_t offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
                u1 flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
                u2 locals_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
                u2 stack_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
                u2 max_locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
                u2 max_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
                VerificationType* locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
                VerificationType* stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
                ClassVerifier* v) : _offset(offset), _flags(flags),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
                                    _locals_size(locals_size),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
                                    _stack_size(stack_size),
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   111
                                    _stack_mark(-1),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
                                    _max_locals(max_locals),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                                    _max_stack(max_stack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
                                    _locals(locals), _stack(stack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                                    _verifier(v) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   117
  static StackMapFrame* copy(StackMapFrame* smf) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   118
    return new StackMapFrame(*smf);
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   119
  }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   120
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  inline void set_offset(int32_t offset)      { _offset = offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  inline void set_verifier(ClassVerifier* v)  { _verifier = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  inline void set_flags(u1 flags)             { _flags = flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  inline void set_locals_size(u2 locals_size) { _locals_size = locals_size; }
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   125
  inline void set_stack_size(u2 stack_size)   { _stack_size = _stack_mark = stack_size; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  inline void clear_stack()                   { _stack_size = 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  inline int32_t offset()   const             { return _offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  inline ClassVerifier* verifier() const      { return _verifier; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  inline u1 flags() const                     { return _flags; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  inline int32_t locals_size() const          { return _locals_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  inline VerificationType* locals() const     { return _locals; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  inline int32_t stack_size() const           { return _stack_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  inline VerificationType* stack() const      { return _stack; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  inline int32_t max_locals() const           { return _max_locals; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  inline int32_t max_stack() const            { return _max_stack; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  inline bool flag_this_uninit() const        { return _flags & FLAG_THIS_UNINIT; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // Set locals and stack types to bogus
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  inline void reset() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    int32_t i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    for (i = 0; i < _max_locals; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
      _locals[i] = VerificationType::bogus_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    for (i = 0; i < _max_stack; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      _stack[i] = VerificationType::bogus_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // Return a StackMapFrame with the same local variable array and empty stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // Stack array is allocate with unused one element.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  StackMapFrame* frame_in_exception_handler(u1 flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // Set local variable type array based on m's signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  VerificationType set_locals_from_arg(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    const methodHandle m, VerificationType thisKlass, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Search local variable type array and stack type array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // Set every element with type of old_object to new_object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  void initialize_object(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    VerificationType old_object, VerificationType new_object);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // Copy local variable type array in src into this local variable type array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  void copy_locals(const StackMapFrame* src);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // Copy stack type array in src into this stack type array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  void copy_stack(const StackMapFrame* src);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // Return true if this stack map frame is assignable to target.
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   169
  bool is_assignable_to(
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   170
      const StackMapFrame* target, bool is_exception_handler,
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   171
      ErrorContext* ctx, TRAPS) const;
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   172
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   173
  inline void set_mark() {
17006
b9bfa72b7dda 7104565: trim jprt build targets
drchase
parents: 15466
diff changeset
   174
#ifdef ASSERT
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   175
    // Put bogus type to indicate it's no longer valid.
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   176
    if (_stack_mark != -1) {
15466
39edb6ef27d1 8007475: Memory stomp with UseMallocOnly
simonis
parents: 13728
diff changeset
   177
      for (int i = _stack_mark - 1; i >= _stack_size; --i) {
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   178
        _stack[i] = VerificationType::bogus_type();
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   179
      }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   180
    }
17006
b9bfa72b7dda 7104565: trim jprt build targets
drchase
parents: 15466
diff changeset
   181
#endif // def ASSERT
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   182
    _stack_mark = _stack_size;
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   183
  }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   184
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   185
  // Used when an error occurs and we want to reset the stack to the state
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   186
  // it was before operands were popped off.
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   187
  void restore() {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   188
    if (_stack_mark != -1) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   189
      _stack_size = _stack_mark;
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   190
    }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   191
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // Push type into stack type array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  inline void push_stack(VerificationType type, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    assert(!type.is_check(), "Must be a real type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    if (_stack_size >= _max_stack) {
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   197
      verifier()->verify_error(
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   198
          ErrorContext::stack_overflow(_offset, this),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   199
          "Operand stack overflow");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    _stack[_stack_size++] = type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  inline void push_stack_2(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
      VerificationType type1, VerificationType type2, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    assert(type1.is_long() || type1.is_double(), "must be long/double");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    assert(type2.is_long2() || type2.is_double2(), "must be long/double_2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    if (_stack_size >= _max_stack - 1) {
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   210
      verifier()->verify_error(
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   211
          ErrorContext::stack_overflow(_offset, this),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   212
          "Operand stack overflow");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    _stack[_stack_size++] = type1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    _stack[_stack_size++] = type2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // Pop and return the top type on stack without verifying.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  inline VerificationType pop_stack(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    if (_stack_size <= 0) {
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   222
      verifier()->verify_error(
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   223
          ErrorContext::stack_underflow(_offset, this),
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   224
          "Operand stack underflow");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
      return VerificationType::bogus_type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    VerificationType top = _stack[--_stack_size];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    return top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  // Pop and return the top type on stack type array after verifying it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  // is assignable to type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  inline VerificationType pop_stack(VerificationType type, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    if (_stack_size != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
      VerificationType top = _stack[_stack_size - 1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      bool subtype = type.is_assignable_from(
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   237
        top, verifier(), CHECK_(VerificationType::bogus_type()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      if (subtype) {
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   239
        --_stack_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
        return top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    return pop_stack_ex(type, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  inline void pop_stack_2(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
      VerificationType type1, VerificationType type2, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    assert(type1.is_long2() || type1.is_double2(), "must be long/double");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    assert(type2.is_long() || type2.is_double(), "must be long/double_2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    if (_stack_size >= 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      VerificationType top1 = _stack[_stack_size - 1];
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   252
      bool subtype1 = type1.is_assignable_from(top1, verifier(), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
      VerificationType top2 = _stack[_stack_size - 2];
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   254
      bool subtype2 = type2.is_assignable_from(top2, verifier(), CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
      if (subtype1 && subtype2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
        _stack_size -= 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
        return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
    pop_stack_ex(type1, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    pop_stack_ex(type2, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   264
  VerificationType local_at(int index) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   265
    return _locals[index];
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   266
  }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   267
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   268
  VerificationType stack_at(int index) {
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   269
    return _stack[index];
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   270
  }
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   271
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  // Uncommon case that throws exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  VerificationType pop_stack_ex(VerificationType type, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  // Return the type at index in local variable array after verifying
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // it is assignable to type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  VerificationType get_local(int32_t index, VerificationType type, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  // For long/double.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  void get_local_2(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    int32_t index, VerificationType type1, VerificationType type2, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // Set element at index in local variable array to type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  void set_local(int32_t index, VerificationType type, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // For long/double.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  void set_local_2(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    int32_t index, VerificationType type1, VerificationType type2, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  // Private auxiliary method used only in is_assignable_to(StackMapFrame).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  // Returns true if src is assignable to target.
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   290
  int is_assignable_to(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    VerificationType* src, VerificationType* target, int32_t len, TRAPS) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
8477
e6f1e62b9e23 7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents: 8076
diff changeset
   293
  bool has_flag_match_exception(const StackMapFrame* target) const;
e6f1e62b9e23 7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents: 8076
diff changeset
   294
13476
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   295
  TypeOrigin stack_top_ctx();
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   296
471200fb94fd 7116786: RFE: Detailed information on VerifyErrors
kamg
parents: 9133
diff changeset
   297
  void print_on(outputStream* str) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   299
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   300
#endif // SHARE_VM_CLASSFILE_STACKMAPFRAME_HPP