Mercurial > hg > truffle
annotate src/share/vm/classfile/stackMapFrame.cpp @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
| author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
|---|---|
| date | Mon, 02 Jan 2012 14:16:08 -0800 |
| parents | 3449f5e02cc4 |
| children | 4ee06e614636 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2303
diff
changeset
|
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/stackMapFrame.hpp" | |
| 27 #include "classfile/verifier.hpp" | |
| 28 #include "memory/resourceArea.hpp" | |
| 29 #include "oops/oop.inline.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
30 #include "oops/symbol.hpp" |
| 1972 | 31 #include "runtime/handles.inline.hpp" |
| 32 #include "utilities/globalDefinitions.hpp" | |
| 0 | 33 |
| 34 StackMapFrame::StackMapFrame(u2 max_locals, u2 max_stack, ClassVerifier* v) : | |
| 35 _offset(0), _locals_size(0), _stack_size(0), _flags(0), | |
| 36 _max_locals(max_locals), _max_stack(max_stack), | |
| 37 _verifier(v) { | |
| 38 Thread* thr = v->thread(); | |
| 39 _locals = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_locals); | |
| 40 _stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, max_stack); | |
| 41 int32_t i; | |
| 42 for(i = 0; i < max_locals; i++) { | |
| 43 _locals[i] = VerificationType::bogus_type(); | |
| 44 } | |
| 45 for(i = 0; i < max_stack; i++) { | |
| 46 _stack[i] = VerificationType::bogus_type(); | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 StackMapFrame* StackMapFrame::frame_in_exception_handler(u1 flags) { | |
| 51 Thread* thr = _verifier->thread(); | |
| 52 VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(thr, VerificationType, 1); | |
| 53 StackMapFrame* frame = new StackMapFrame(_offset, flags, _locals_size, 0, _max_locals, _max_stack, _locals, stack, _verifier); | |
| 54 return frame; | |
| 55 } | |
| 56 | |
| 57 bool StackMapFrame::has_new_object() const { | |
| 58 int32_t i; | |
| 59 for (i = 0; i < _max_locals; i++) { | |
| 60 if (_locals[i].is_uninitialized()) { | |
| 61 return true; | |
| 62 } | |
| 63 } | |
| 64 for (i = 0; i < _stack_size; i++) { | |
| 65 if (_stack[i].is_uninitialized()) { | |
| 66 return true; | |
| 67 } | |
| 68 } | |
| 69 return false; | |
| 70 } | |
| 71 | |
| 72 void StackMapFrame::initialize_object( | |
| 73 VerificationType old_object, VerificationType new_object) { | |
| 74 int32_t i; | |
| 75 for (i = 0; i < _max_locals; i++) { | |
| 76 if (_locals[i].equals(old_object)) { | |
| 77 _locals[i] = new_object; | |
| 78 } | |
| 79 } | |
| 80 for (i = 0; i < _stack_size; i++) { | |
| 81 if (_stack[i].equals(old_object)) { | |
| 82 _stack[i] = new_object; | |
| 83 } | |
| 84 } | |
| 85 if (old_object == VerificationType::uninitialized_this_type()) { | |
| 86 // "this" has been initialized - reset flags | |
| 87 _flags = 0; | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 VerificationType StackMapFrame::set_locals_from_arg( | |
| 92 const methodHandle m, VerificationType thisKlass, TRAPS) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
93 SignatureStream ss(m->signature()); |
| 0 | 94 int init_local_num = 0; |
| 95 if (!m->is_static()) { | |
| 96 init_local_num++; | |
| 97 // add one extra argument for instance method | |
| 98 if (m->name() == vmSymbols::object_initializer_name() && | |
| 99 thisKlass.name() != vmSymbols::java_lang_Object()) { | |
| 100 _locals[0] = VerificationType::uninitialized_this_type(); | |
| 101 _flags |= FLAG_THIS_UNINIT; | |
| 102 } else { | |
| 103 _locals[0] = thisKlass; | |
| 104 } | |
| 105 } | |
| 106 | |
| 107 // local num may be greater than size of parameters because long/double occupies two slots | |
| 108 while(!ss.at_return_type()) { | |
| 109 init_local_num += _verifier->change_sig_to_verificationType( | |
| 110 &ss, &_locals[init_local_num], | |
| 111 CHECK_VERIFY_(verifier(), VerificationType::bogus_type())); | |
| 112 ss.next(); | |
| 113 } | |
| 114 _locals_size = init_local_num; | |
| 115 | |
| 116 switch (ss.type()) { | |
| 117 case T_OBJECT: | |
| 118 case T_ARRAY: | |
| 119 { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
120 Symbol* sig = ss.as_symbol(CHECK_(VerificationType::bogus_type())); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
121 // Create another symbol to save as signature stream unreferences |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
122 // this symbol. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
123 Symbol* sig_copy = |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
124 verifier()->create_temporary_symbol(sig, 0, sig->utf8_length(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
125 CHECK_(VerificationType::bogus_type())); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
126 assert(sig_copy == sig, "symbols don't match"); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
127 return VerificationType::reference_type(sig_copy); |
| 0 | 128 } |
| 129 case T_INT: return VerificationType::integer_type(); | |
| 130 case T_BYTE: return VerificationType::byte_type(); | |
| 131 case T_CHAR: return VerificationType::char_type(); | |
| 132 case T_SHORT: return VerificationType::short_type(); | |
| 133 case T_BOOLEAN: return VerificationType::boolean_type(); | |
| 134 case T_FLOAT: return VerificationType::float_type(); | |
| 135 case T_DOUBLE: return VerificationType::double_type(); | |
| 136 case T_LONG: return VerificationType::long_type(); | |
| 137 case T_VOID: return VerificationType::bogus_type(); | |
| 138 default: | |
| 139 ShouldNotReachHere(); | |
| 140 } | |
| 141 return VerificationType::bogus_type(); | |
| 142 } | |
| 143 | |
| 144 void StackMapFrame::copy_locals(const StackMapFrame* src) { | |
| 145 int32_t len = src->locals_size() < _locals_size ? | |
| 146 src->locals_size() : _locals_size; | |
| 147 for (int32_t i = 0; i < len; i++) { | |
| 148 _locals[i] = src->locals()[i]; | |
| 149 } | |
| 150 } | |
| 151 | |
| 152 void StackMapFrame::copy_stack(const StackMapFrame* src) { | |
| 153 int32_t len = src->stack_size() < _stack_size ? | |
| 154 src->stack_size() : _stack_size; | |
| 155 for (int32_t i = 0; i < len; i++) { | |
| 156 _stack[i] = src->stack()[i]; | |
| 157 } | |
| 158 } | |
| 159 | |
| 160 | |
| 161 bool StackMapFrame::is_assignable_to( | |
| 162 VerificationType* from, VerificationType* to, int32_t len, TRAPS) const { | |
| 163 for (int32_t i = 0; i < len; i++) { | |
| 164 bool subtype = to[i].is_assignable_from( | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
165 from[i], verifier(), THREAD); |
| 0 | 166 if (!subtype) { |
| 167 return false; | |
| 168 } | |
| 169 } | |
| 170 return true; | |
| 171 } | |
| 172 | |
|
2303
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
173 bool StackMapFrame::has_flag_match_exception( |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
174 const StackMapFrame* target) const { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
175 // We allow flags of {UninitThis} to assign to {} if-and-only-if the |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
176 // target frame does not depend upon the current type. |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
177 // This is slightly too strict, as we need only enforce that the |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
178 // slots that were initialized by the <init> (the things that were |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
179 // UninitializedThis before initialize_object() converted them) are unused. |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
180 // However we didn't save that information so we'll enforce this upon |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
181 // anything that might have been initialized. This is a rare situation |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
182 // and javac never generates code that would end up here, but some profilers |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
183 // (such as NetBeans) might, when adding exception handlers in <init> |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
184 // methods to cover the invokespecial instruction. See 7020118. |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
185 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
186 assert(max_locals() == target->max_locals() && |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
187 stack_size() == target->stack_size(), "StackMap sizes must match"); |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
188 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
189 VerificationType top = VerificationType::top_type(); |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
190 VerificationType this_type = verifier()->current_type(); |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
191 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
192 if (!flag_this_uninit() || target->flags() != 0) { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
193 return false; |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
194 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
195 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
196 for (int i = 0; i < target->locals_size(); ++i) { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
197 if (locals()[i] == this_type && target->locals()[i] != top) { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
198 return false; |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
199 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
200 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
201 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
202 for (int i = 0; i < target->stack_size(); ++i) { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
203 if (stack()[i] == this_type && target->stack()[i] != top) { |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
204 return false; |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
205 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
206 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
207 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
208 return true; |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
209 } |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
210 |
|
2472
7144a1d6e0a9
7030388: JCK test failed to reject invalid class check01304m10n.
kamg
parents:
2303
diff
changeset
|
211 bool StackMapFrame::is_assignable_to( |
|
7144a1d6e0a9
7030388: JCK test failed to reject invalid class check01304m10n.
kamg
parents:
2303
diff
changeset
|
212 const StackMapFrame* target, bool is_exception_handler, TRAPS) const { |
|
7144a1d6e0a9
7030388: JCK test failed to reject invalid class check01304m10n.
kamg
parents:
2303
diff
changeset
|
213 if (_max_locals != target->max_locals() || |
|
7144a1d6e0a9
7030388: JCK test failed to reject invalid class check01304m10n.
kamg
parents:
2303
diff
changeset
|
214 _stack_size != target->stack_size()) { |
| 0 | 215 return false; |
| 216 } | |
| 217 // Only need to compare type elements up to target->locals() or target->stack(). | |
| 218 // The remaining type elements in this state can be ignored because they are | |
| 219 // assignable to bogus type. | |
| 220 bool match_locals = is_assignable_to( | |
| 221 _locals, target->locals(), target->locals_size(), CHECK_false); | |
| 222 bool match_stack = is_assignable_to( | |
| 223 _stack, target->stack(), _stack_size, CHECK_false); | |
| 224 bool match_flags = (_flags | target->flags()) == target->flags(); | |
|
2303
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
225 |
|
c1a6154012c8
7020118: Alter frame assignability to allow for exception handler coverage of invokespecial <init>
kamg
parents:
2177
diff
changeset
|
226 return match_locals && match_stack && |
|
2472
7144a1d6e0a9
7030388: JCK test failed to reject invalid class check01304m10n.
kamg
parents:
2303
diff
changeset
|
227 (match_flags || (is_exception_handler && has_flag_match_exception(target))); |
| 0 | 228 } |
| 229 | |
| 230 VerificationType StackMapFrame::pop_stack_ex(VerificationType type, TRAPS) { | |
| 231 if (_stack_size <= 0) { | |
| 232 verifier()->verify_error(_offset, "Operand stack underflow"); | |
| 233 return VerificationType::bogus_type(); | |
| 234 } | |
| 235 VerificationType top = _stack[--_stack_size]; | |
| 236 bool subtype = type.is_assignable_from( | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
237 top, verifier(), CHECK_(VerificationType::bogus_type())); |
| 0 | 238 if (!subtype) { |
| 239 verifier()->verify_error(_offset, "Bad type on operand stack"); | |
| 240 return VerificationType::bogus_type(); | |
| 241 } | |
| 242 NOT_PRODUCT( _stack[_stack_size] = VerificationType::bogus_type(); ) | |
| 243 return top; | |
| 244 } | |
| 245 | |
| 246 VerificationType StackMapFrame::get_local( | |
| 247 int32_t index, VerificationType type, TRAPS) { | |
| 248 if (index >= _max_locals) { | |
| 249 verifier()->verify_error(_offset, "Local variable table overflow"); | |
| 250 return VerificationType::bogus_type(); | |
| 251 } | |
| 252 bool subtype = type.is_assignable_from(_locals[index], | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
253 verifier(), CHECK_(VerificationType::bogus_type())); |
| 0 | 254 if (!subtype) { |
| 255 verifier()->verify_error(_offset, "Bad local variable type"); | |
| 256 return VerificationType::bogus_type(); | |
| 257 } | |
| 258 if(index >= _locals_size) { _locals_size = index + 1; } | |
| 259 return _locals[index]; | |
| 260 } | |
| 261 | |
| 262 void StackMapFrame::get_local_2( | |
| 263 int32_t index, VerificationType type1, VerificationType type2, TRAPS) { | |
| 264 assert(type1.is_long() || type1.is_double(), "must be long/double"); | |
| 265 assert(type2.is_long2() || type2.is_double2(), "must be long/double_2"); | |
| 266 if (index >= _locals_size - 1) { | |
| 267 verifier()->verify_error(_offset, "get long/double overflows locals"); | |
| 268 return; | |
| 269 } | |
| 270 bool subtype1 = type1.is_assignable_from( | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
271 _locals[index], verifier(), CHECK); |
| 0 | 272 bool subtype2 = type2.is_assignable_from( |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
273 _locals[index+1], verifier(), CHECK); |
| 0 | 274 if (!subtype1 || !subtype2) { |
| 275 verifier()->verify_error(_offset, "Bad local variable type"); | |
| 276 return; | |
| 277 } | |
| 278 } | |
| 279 | |
| 280 void StackMapFrame::set_local(int32_t index, VerificationType type, TRAPS) { | |
| 281 assert(!type.is_check(), "Must be a real type"); | |
| 282 if (index >= _max_locals) { | |
| 283 verifier()->verify_error("Local variable table overflow", _offset); | |
| 284 return; | |
| 285 } | |
| 286 // If type at index is double or long, set the next location to be unusable | |
| 287 if (_locals[index].is_double() || _locals[index].is_long()) { | |
| 288 assert((index + 1) < _locals_size, "Local variable table overflow"); | |
| 289 _locals[index + 1] = VerificationType::bogus_type(); | |
| 290 } | |
| 291 // If type at index is double_2 or long_2, set the previous location to be unusable | |
| 292 if (_locals[index].is_double2() || _locals[index].is_long2()) { | |
| 293 assert(index >= 1, "Local variable table underflow"); | |
| 294 _locals[index - 1] = VerificationType::bogus_type(); | |
| 295 } | |
| 296 _locals[index] = type; | |
| 297 if (index >= _locals_size) { | |
| 298 #ifdef ASSERT | |
| 299 for (int i=_locals_size; i<index; i++) { | |
| 300 assert(_locals[i] == VerificationType::bogus_type(), | |
| 301 "holes must be bogus type"); | |
| 302 } | |
| 303 #endif | |
| 304 _locals_size = index + 1; | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 void StackMapFrame::set_local_2( | |
| 309 int32_t index, VerificationType type1, VerificationType type2, TRAPS) { | |
| 310 assert(type1.is_long() || type1.is_double(), "must be long/double"); | |
| 311 assert(type2.is_long2() || type2.is_double2(), "must be long/double_2"); | |
| 312 if (index >= _max_locals - 1) { | |
| 313 verifier()->verify_error("Local variable table overflow", _offset); | |
| 314 return; | |
| 315 } | |
| 316 // If type at index+1 is double or long, set the next location to be unusable | |
| 317 if (_locals[index+1].is_double() || _locals[index+1].is_long()) { | |
| 318 assert((index + 2) < _locals_size, "Local variable table overflow"); | |
| 319 _locals[index + 2] = VerificationType::bogus_type(); | |
| 320 } | |
| 321 // If type at index is double_2 or long_2, set the previous location to be unusable | |
| 322 if (_locals[index].is_double2() || _locals[index].is_long2()) { | |
| 323 assert(index >= 1, "Local variable table underflow"); | |
| 324 _locals[index - 1] = VerificationType::bogus_type(); | |
| 325 } | |
| 326 _locals[index] = type1; | |
| 327 _locals[index+1] = type2; | |
| 328 if (index >= _locals_size - 1) { | |
| 329 #ifdef ASSERT | |
| 330 for (int i=_locals_size; i<index; i++) { | |
| 331 assert(_locals[i] == VerificationType::bogus_type(), | |
| 332 "holes must be bogus type"); | |
| 333 } | |
| 334 #endif | |
| 335 _locals_size = index + 2; | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 #ifndef PRODUCT | |
| 340 | |
| 341 void StackMapFrame::print() const { | |
| 342 tty->print_cr("stackmap_frame[%d]:", _offset); | |
| 343 tty->print_cr("flags = 0x%x", _flags); | |
| 344 tty->print("locals[%d] = { ", _locals_size); | |
| 345 for (int32_t i = 0; i < _locals_size; i++) { | |
| 346 _locals[i].print_on(tty); | |
| 347 } | |
| 348 tty->print_cr(" }"); | |
| 349 tty->print("stack[%d] = { ", _stack_size); | |
| 350 for (int32_t j = 0; j < _stack_size; j++) { | |
| 351 _stack[j].print_on(tty); | |
| 352 } | |
| 353 tty->print_cr(" }"); | |
| 354 } | |
| 355 | |
| 356 #endif |