1 /* 2 * Copyright (c) 2003, 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 #include "precompiled.hpp" 26 #include "classfile/stackMapTable.hpp" 27 #include "classfile/verifier.hpp" 28 #include "memory/resourceArea.hpp" 29 #include "oops/oop.inline.hpp" 30 #include "runtime/fieldType.hpp" 31 #include "runtime/handles.inline.hpp" 32 33 StackMapTable::StackMapTable(StackMapReader* reader, StackMapFrame* init_frame, 34 u2 max_locals, u2 max_stack, 35 char* code_data, int code_len, TRAPS) { 36 _code_length = code_len; 37 _frame_count = reader->get_frame_count(); 38 if (_frame_count > 0) { 39 _frame_array = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, 40 StackMapFrame*, _frame_count); 41 StackMapFrame* pre_frame = init_frame; 42 for (int32_t i = 0; i < _frame_count; i++) { 43 StackMapFrame* frame = reader->next( 44 pre_frame, i == 0, max_locals, max_stack, 45 CHECK_VERIFY(pre_frame->verifier())); 46 _frame_array[i] = frame; 47 int offset = frame->offset(); 48 if (offset >= code_len || code_data[offset] == 0) { 49 frame->verifier()->verify_error( 50 ErrorContext::bad_stackmap(i, frame), 51 "StackMapTable error: bad offset"); 52 return; 53 } 54 pre_frame = frame; 55 } 56 } 57 reader->check_end(CHECK); 58 } 59 60 // This method is only called by method in StackMapTable. 61 int StackMapTable::get_index_from_offset(int32_t offset) const { 62 int i = 0; 63 for (; i < _frame_count; i++) { 64 if (_frame_array[i]->offset() == offset) { 65 return i; 66 } 67 } 68 return i; // frame with offset doesn't exist in the array 69 } 70 71 bool StackMapTable::match_stackmap( 72 StackMapFrame* frame, int32_t target, 73 bool match, bool update, ErrorContext* ctx, TRAPS) const { 74 int index = get_index_from_offset(target); 75 return match_stackmap(frame, target, index, match, update, ctx, THREAD); 76 } 77 78 // Match and/or update current_frame to the frame in stackmap table with 79 // specified offset and frame index. Return true if the two frames match. 80 // 81 // The values of match and update are: _match__update 82 // 83 // checking a branch target: true false 84 // checking an exception handler: true false 85 // linear bytecode verification following an 86 // unconditional branch: false true 87 // linear bytecode verification not following an 88 // unconditional branch: true true 89 bool StackMapTable::match_stackmap( 90 StackMapFrame* frame, int32_t target, int32_t frame_index, 91 bool match, bool update, ErrorContext* ctx, TRAPS) const { 92 if (frame_index < 0 || frame_index >= _frame_count) { 93 *ctx = ErrorContext::missing_stackmap(frame->offset()); 94 frame->verifier()->verify_error( 95 *ctx, "Expecting a stackmap frame at branch target %d", target); 96 return false; 97 } 98 99 StackMapFrame *stackmap_frame = _frame_array[frame_index]; 100 bool result = true; 101 if (match) { 102 // Has direct control flow from last instruction, need to match the two 103 // frames. 104 result = frame->is_assignable_to(stackmap_frame, 105 ctx, CHECK_VERIFY_(frame->verifier(), result)); 106 } 107 if (update) { 108 // Use the frame in stackmap table as current frame 109 int lsize = stackmap_frame->locals_size(); 110 int ssize = stackmap_frame->stack_size(); 111 if (frame->locals_size() > lsize || frame->stack_size() > ssize) { 112 // Make sure unused type array items are all _bogus_type. 113 frame->reset(); 114 } 115 frame->set_locals_size(lsize); 116 frame->copy_locals(stackmap_frame); 117 frame->set_stack_size(ssize); 118 frame->copy_stack(stackmap_frame); 119 frame->set_flags(stackmap_frame->flags()); 120 } 121 return result; 122 } 123 124 void StackMapTable::check_jump_target( 125 StackMapFrame* frame, int32_t target, TRAPS) const { 126 ErrorContext ctx; 127 bool match = match_stackmap( 128 frame, target, true, false, &ctx, CHECK_VERIFY(frame->verifier())); 129 if (!match || (target < 0 || target >= _code_length)) { 130 frame->verifier()->verify_error(ctx, 131 "Inconsistent stackmap frames at branch target %d", target); 132 } 133 } 134 135 void StackMapTable::print_on(outputStream* str) const { 136 str->indent().print_cr("StackMapTable: frame_count = %d", _frame_count); 137 str->indent().print_cr("table = { "); 138 { 139 streamIndentor si(str); 140 for (int32_t i = 0; i < _frame_count; ++i) { 141 _frame_array[i]->print_on(str); 142 } 143 } 144 str->print_cr(" }"); 145 } 146 147 int32_t StackMapReader::chop( 148 VerificationType* locals, int32_t length, int32_t chops) { 149 if (locals == NULL) return -1; 150 int32_t pos = length - 1; 151 for (int32_t i=0; i<chops; i++) { 152 if (locals[pos].is_category2_2nd()) { 153 pos -= 2; 154 } else { 155 pos --; 156 } 157 if (pos<0 && i<(chops-1)) return -1; 158 } 159 return pos+1; 160 } 161 162 VerificationType StackMapReader::parse_verification_type(u1* flags, TRAPS) { 163 u1 tag = _stream->get_u1(THREAD); 164 if (tag < (u1)ITEM_UninitializedThis) { 165 return VerificationType::from_tag(tag); 166 } 167 if (tag == ITEM_Object) { 168 u2 class_index = _stream->get_u2(THREAD); 169 int nconstants = _cp->length(); 170 if ((class_index <= 0 || class_index >= nconstants) || 171 (!_cp->tag_at(class_index).is_klass() && 172 !_cp->tag_at(class_index).is_unresolved_klass())) { 173 _stream->stackmap_format_error("bad class index", THREAD); 174 return VerificationType::bogus_type(); 175 } 176 return VerificationType::reference_type(_cp->klass_name_at(class_index)); 177 } 178 if (tag == ITEM_UninitializedThis) { 179 if (flags != NULL) { 180 *flags |= FLAG_THIS_UNINIT; 181 } 182 return VerificationType::uninitialized_this_type(); 183 } 184 if (tag == ITEM_Uninitialized) { 185 u2 offset = _stream->get_u2(THREAD); 186 if (offset >= _code_length || 187 _code_data[offset] != ClassVerifier::NEW_OFFSET) { 188 _verifier->class_format_error( 189 "StackMapTable format error: bad offset for Uninitialized"); 190 return VerificationType::bogus_type(); 191 } 192 return VerificationType::uninitialized_type(offset); 193 } 194 _stream->stackmap_format_error("bad verification type", THREAD); 195 return VerificationType::bogus_type(); 196 } 197 198 StackMapFrame* StackMapReader::next( 199 StackMapFrame* pre_frame, bool first, u2 max_locals, u2 max_stack, TRAPS) { 200 StackMapFrame* frame; 201 int offset; 202 VerificationType* locals = NULL; 203 u1 frame_type = _stream->get_u1(THREAD); 204 if (frame_type < 64) { 205 // same_frame 206 if (first) { 207 offset = frame_type; 208 // Can't share the locals array since that is updated by the verifier. 209 if (pre_frame->locals_size() > 0) { 210 locals = NEW_RESOURCE_ARRAY_IN_THREAD( 211 THREAD, VerificationType, pre_frame->locals_size()); 212 } 213 } else { 214 offset = pre_frame->offset() + frame_type + 1; 215 locals = pre_frame->locals(); 216 } 217 frame = new StackMapFrame( 218 offset, pre_frame->flags(), pre_frame->locals_size(), 0, 219 max_locals, max_stack, locals, NULL, _verifier); 220 if (first && locals != NULL) { 221 frame->copy_locals(pre_frame); 222 } 223 return frame; 224 } 225 if (frame_type < 128) { 226 // same_locals_1_stack_item_frame 227 if (first) { 228 offset = frame_type - 64; 229 // Can't share the locals array since that is updated by the verifier. 230 if (pre_frame->locals_size() > 0) { 231 locals = NEW_RESOURCE_ARRAY_IN_THREAD( 232 THREAD, VerificationType, pre_frame->locals_size()); 233 } 234 } else { 235 offset = pre_frame->offset() + frame_type - 63; 236 locals = pre_frame->locals(); 237 } 238 VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD( 239 THREAD, VerificationType, 2); 240 u2 stack_size = 1; 241 stack[0] = parse_verification_type(NULL, CHECK_VERIFY_(_verifier, NULL)); 242 if (stack[0].is_category2()) { 243 stack[1] = stack[0].to_category2_2nd(); 244 stack_size = 2; 245 } 246 check_verification_type_array_size( 247 stack_size, max_stack, CHECK_VERIFY_(_verifier, NULL)); 248 frame = new StackMapFrame( 249 offset, pre_frame->flags(), pre_frame->locals_size(), stack_size, 250 max_locals, max_stack, locals, stack, _verifier); 251 if (first && locals != NULL) { 252 frame->copy_locals(pre_frame); 253 } 254 return frame; 255 } 256 257 u2 offset_delta = _stream->get_u2(THREAD); 258 259 if (frame_type < SAME_LOCALS_1_STACK_ITEM_EXTENDED) { 260 // reserved frame types 261 _stream->stackmap_format_error( 262 "reserved frame type", CHECK_VERIFY_(_verifier, NULL)); 263 } 264 265 if (frame_type == SAME_LOCALS_1_STACK_ITEM_EXTENDED) { 266 // same_locals_1_stack_item_frame_extended 267 if (first) { 268 offset = offset_delta; 269 // Can't share the locals array since that is updated by the verifier. 270 if (pre_frame->locals_size() > 0) { 271 locals = NEW_RESOURCE_ARRAY_IN_THREAD( 272 THREAD, VerificationType, pre_frame->locals_size()); 273 } 274 } else { 275 offset = pre_frame->offset() + offset_delta + 1; 276 locals = pre_frame->locals(); 277 } 278 VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD( 279 THREAD, VerificationType, 2); 280 u2 stack_size = 1; 281 stack[0] = parse_verification_type(NULL, CHECK_VERIFY_(_verifier, NULL)); 282 if (stack[0].is_category2()) { 283 stack[1] = stack[0].to_category2_2nd(); 284 stack_size = 2; 285 } 286 check_verification_type_array_size( 287 stack_size, max_stack, CHECK_VERIFY_(_verifier, NULL)); 288 frame = new StackMapFrame( 289 offset, pre_frame->flags(), pre_frame->locals_size(), stack_size, 290 max_locals, max_stack, locals, stack, _verifier); 291 if (first && locals != NULL) { 292 frame->copy_locals(pre_frame); 293 } 294 return frame; 295 } 296 297 if (frame_type <= SAME_EXTENDED) { 298 // chop_frame or same_frame_extended 299 locals = pre_frame->locals(); 300 int length = pre_frame->locals_size(); 301 int chops = SAME_EXTENDED - frame_type; 302 int new_length = length; 303 u1 flags = pre_frame->flags(); 304 if (chops != 0) { 305 new_length = chop(locals, length, chops); 306 check_verification_type_array_size( 307 new_length, max_locals, CHECK_VERIFY_(_verifier, NULL)); 308 // Recompute flags since uninitializedThis could have been chopped. 309 flags = 0; 310 for (int i=0; i<new_length; i++) { 311 if (locals[i].is_uninitialized_this()) { 312 flags |= FLAG_THIS_UNINIT; 313 break; 314 } 315 } 316 } 317 if (first) { 318 offset = offset_delta; 319 // Can't share the locals array since that is updated by the verifier. 320 if (new_length > 0) { 321 locals = NEW_RESOURCE_ARRAY_IN_THREAD( 322 THREAD, VerificationType, new_length); 323 } else { 324 locals = NULL; 325 } 326 } else { 327 offset = pre_frame->offset() + offset_delta + 1; 328 } 329 frame = new StackMapFrame( 330 offset, flags, new_length, 0, max_locals, max_stack, 331 locals, NULL, _verifier); 332 if (first && locals != NULL) { 333 frame->copy_locals(pre_frame); 334 } 335 return frame; 336 } else if (frame_type < SAME_EXTENDED + 4) { 337 // append_frame 338 int appends = frame_type - SAME_EXTENDED; 339 int real_length = pre_frame->locals_size(); 340 int new_length = real_length + appends*2; 341 locals = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, VerificationType, new_length); 342 VerificationType* pre_locals = pre_frame->locals(); 343 int i; 344 for (i=0; i<pre_frame->locals_size(); i++) { 345 locals[i] = pre_locals[i]; 346 } 347 u1 flags = pre_frame->flags(); 348 for (i=0; i<appends; i++) { 349 locals[real_length] = parse_verification_type(&flags, THREAD); 350 if (locals[real_length].is_category2()) { 351 locals[real_length + 1] = locals[real_length].to_category2_2nd(); 352 ++real_length; 353 } 354 ++real_length; 355 } 356 check_verification_type_array_size( 357 real_length, max_locals, CHECK_VERIFY_(_verifier, NULL)); 358 if (first) { 359 offset = offset_delta; 360 } else { 361 offset = pre_frame->offset() + offset_delta + 1; 362 } 363 frame = new StackMapFrame( 364 offset, flags, real_length, 0, max_locals, 365 max_stack, locals, NULL, _verifier); 366 return frame; 367 } 368 if (frame_type == FULL) { 369 // full_frame 370 u1 flags = 0; 371 u2 locals_size = _stream->get_u2(THREAD); 372 int real_locals_size = 0; 373 if (locals_size > 0) { 374 locals = NEW_RESOURCE_ARRAY_IN_THREAD( 375 THREAD, VerificationType, locals_size*2); 376 } 377 int i; 378 for (i=0; i<locals_size; i++) { 379 locals[real_locals_size] = parse_verification_type(&flags, THREAD); 380 if (locals[real_locals_size].is_category2()) { 381 locals[real_locals_size + 1] = 382 locals[real_locals_size].to_category2_2nd(); 383 ++real_locals_size; 384 } 385 ++real_locals_size; 386 } 387 check_verification_type_array_size( 388 real_locals_size, max_locals, CHECK_VERIFY_(_verifier, NULL)); 389 u2 stack_size = _stream->get_u2(THREAD); 390 int real_stack_size = 0; 391 VerificationType* stack = NULL; 392 if (stack_size > 0) { 393 stack = NEW_RESOURCE_ARRAY_IN_THREAD( 394 THREAD, VerificationType, stack_size*2); 395 } 396 for (i=0; i<stack_size; i++) { 397 stack[real_stack_size] = parse_verification_type(NULL, THREAD); 398 if (stack[real_stack_size].is_category2()) { 399 stack[real_stack_size + 1] = stack[real_stack_size].to_category2_2nd(); 400 ++real_stack_size; 401 } 402 ++real_stack_size; 403 } 404 check_verification_type_array_size( 405 real_stack_size, max_stack, CHECK_VERIFY_(_verifier, NULL)); 406 if (first) { 407 offset = offset_delta; 408 } else { 409 offset = pre_frame->offset() + offset_delta + 1; 410 } 411 frame = new StackMapFrame( 412 offset, flags, real_locals_size, real_stack_size, 413 max_locals, max_stack, locals, stack, _verifier); 414 return frame; 415 } 416 417 _stream->stackmap_format_error( 418 "reserved frame type", CHECK_VERIFY_(pre_frame->verifier(), NULL)); 419 return NULL; 420 }