< prev index next >

src/hotspot/share/classfile/stackMapTable.cpp

Print this page

110   bool result = true;
111   if (match) {
112     // Has direct control flow from last instruction, need to match the two
113     // frames.
114     result = frame->is_assignable_to(stackmap_frame,
115         ctx, CHECK_VERIFY_(frame->verifier(), result));
116   }
117   if (update) {
118     // Use the frame in stackmap table as current frame
119     int lsize = stackmap_frame->locals_size();
120     int ssize = stackmap_frame->stack_size();
121     if (frame->locals_size() > lsize || frame->stack_size() > ssize) {
122       // Make sure unused type array items are all _bogus_type.
123       frame->reset();
124     }
125     frame->set_locals_size(lsize);
126     frame->copy_locals(stackmap_frame);
127     frame->set_stack_size(ssize);
128     frame->copy_stack(stackmap_frame);
129     frame->set_flags(stackmap_frame->flags());

130   }
131   return result;
132 }
133 
134 void StackMapTable::check_jump_target(
135     StackMapFrame* frame, int32_t target, TRAPS) const {
136   ErrorContext ctx;
137   bool match = match_stackmap(
138     frame, target, true, false, &ctx, CHECK_VERIFY(frame->verifier()));
139   if (!match || (target < 0 || target >= _code_length)) {
140     frame->verifier()->verify_error(ctx,
141         "Inconsistent stackmap frames at branch target %d", target);
142   }
143 }
144 
145 void StackMapTable::print_on(outputStream* str) const {
146   str->indent().print_cr("StackMapTable: frame_count = %d", _frame_count);
147   str->indent().print_cr("table = { ");
148   {
149     streamIndentor si(str);
150     for (int32_t i = 0; i < _frame_count; ++i) {
151       _frame_array->at(i)->print_on(str);
152     }
153   }
154   str->print_cr(" }");
155 }
156 
157 StackMapReader::StackMapReader(ClassVerifier* v, StackMapStream* stream,
158                                char* code_data, int32_t code_len,
159                                StackMapFrame* init_frame,
160                                u2 max_locals, u2 max_stack, TRAPS) :

161                                   _verifier(v), _stream(stream), _code_data(code_data),
162                                   _code_length(code_len), _parsed_frame_count(0),
163                                   _prev_frame(init_frame), _max_locals(max_locals),
164                                   _max_stack(max_stack), _first(true) {

165   methodHandle m = v->method();
166   if (m->has_stackmap_table()) {
167     _cp = constantPoolHandle(THREAD, m->constants());
168     _frame_count = _stream->get_u2(CHECK);
169   } else {
170     // There's no stackmap table present. Frame count and size are 0.
171     _frame_count = 0;
172   }
173 }
174 
175 int32_t StackMapReader::chop(
176     VerificationType* locals, int32_t length, int32_t chops) {
177   if (locals == nullptr) return -1;
178   int32_t pos = length - 1;
179   for (int32_t i=0; i<chops; i++) {
180     if (locals[pos].is_category2_2nd()) {
181       pos -= 2;
182     } else {
183       pos --;
184     }

186   }
187   return pos+1;
188 }
189 
190 #define CHECK_NT CHECK_(VerificationType::bogus_type())
191 
192 VerificationType StackMapReader::parse_verification_type(u1* flags, TRAPS) {
193   u1 tag = _stream->get_u1(CHECK_NT);
194   if (tag < (u1)ITEM_UninitializedThis) {
195     return VerificationType::from_tag(tag);
196   }
197   if (tag == ITEM_Object) {
198     u2 class_index = _stream->get_u2(CHECK_NT);
199     int nconstants = _cp->length();
200     if ((class_index <= 0 || class_index >= nconstants) ||
201         (!_cp->tag_at(class_index).is_klass() &&
202          !_cp->tag_at(class_index).is_unresolved_klass())) {
203       _stream->stackmap_format_error("bad class index", THREAD);
204       return VerificationType::bogus_type();
205     }
206     return VerificationType::reference_type(_cp->klass_name_at(class_index));

207   }
208   if (tag == ITEM_UninitializedThis) {
209     if (flags != nullptr) {
210       *flags |= FLAG_THIS_UNINIT;
211     }
212     return VerificationType::uninitialized_this_type();
213   }
214   if (tag == ITEM_Uninitialized) {
215     u2 offset = _stream->get_u2(CHECK_NT);
216     if (offset >= _code_length ||
217         _code_data[offset] != ClassVerifier::NEW_OFFSET) {
218       _verifier->class_format_error(
219         "StackMapTable format error: bad offset for Uninitialized");
220       return VerificationType::bogus_type();
221     }
222     return VerificationType::uninitialized_type(offset);
223   }
224   _stream->stackmap_format_error("bad verification type", THREAD);
225   return VerificationType::bogus_type();
226 }
227 
228 StackMapFrame* StackMapReader::next(TRAPS) {
229   _parsed_frame_count++;
230   check_size(CHECK_NULL);
231   StackMapFrame* frame = next_helper(CHECK_VERIFY_(_verifier, nullptr));
232   if (frame != nullptr) {
233     check_offset(frame);
234     if (frame->verifier()->has_error()) {
235       return nullptr;
236     }
237     _prev_frame = frame;
238   }
239   return frame;
240 }
241 
242 StackMapFrame* StackMapReader::next_helper(TRAPS) {
243   StackMapFrame* frame;
244   int offset;
245   VerificationType* locals = nullptr;
246   u1 frame_type = _stream->get_u1(CHECK_NULL);

























































247   if (frame_type < 64) {
248     // same_frame
249     if (_first) {
250       offset = frame_type;
251       // Can't share the locals array since that is updated by the verifier.
252       if (_prev_frame->locals_size() > 0) {
253         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
254           THREAD, VerificationType, _prev_frame->locals_size());
255       }
256     } else {
257       offset = _prev_frame->offset() + frame_type + 1;
258       locals = _prev_frame->locals();
259     }
260     frame = new StackMapFrame(
261       offset, _prev_frame->flags(), _prev_frame->locals_size(), 0,
262       _max_locals, _max_stack, locals, nullptr, _verifier);

263     if (_first && locals != nullptr) {
264       frame->copy_locals(_prev_frame);
265     }
266     _first = false;
267     return frame;
268   }
269   if (frame_type < 128) {
270     // same_locals_1_stack_item_frame
271     if (_first) {
272       offset = frame_type - 64;
273       // Can't share the locals array since that is updated by the verifier.
274       if (_prev_frame->locals_size() > 0) {
275         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
276           THREAD, VerificationType, _prev_frame->locals_size());
277       }
278     } else {
279       offset = _prev_frame->offset() + frame_type - 63;
280       locals = _prev_frame->locals();
281     }
282     VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(
283       THREAD, VerificationType, 2);
284     u2 stack_size = 1;
285     stack[0] = parse_verification_type(nullptr, CHECK_VERIFY_(_verifier, nullptr));
286     if (stack[0].is_category2()) {
287       stack[1] = stack[0].to_category2_2nd();
288       stack_size = 2;
289     }
290     check_verification_type_array_size(
291       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
292     frame = new StackMapFrame(
293       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
294       _max_locals, _max_stack, locals, stack, _verifier);

295     if (_first && locals != nullptr) {
296       frame->copy_locals(_prev_frame);
297     }
298     _first = false;
299     return frame;
300   }
301 
302   u2 offset_delta = _stream->get_u2(CHECK_NULL);
303 
304   if (frame_type < SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
305     // reserved frame types
306     _stream->stackmap_format_error(
307       "reserved frame type", CHECK_VERIFY_(_verifier, nullptr));
308   }
309 
310   if (frame_type == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
311     // same_locals_1_stack_item_frame_extended
312     if (_first) {
313       offset = offset_delta;
314       // Can't share the locals array since that is updated by the verifier.
315       if (_prev_frame->locals_size() > 0) {
316         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
317           THREAD, VerificationType, _prev_frame->locals_size());
318       }
319     } else {
320       offset = _prev_frame->offset() + offset_delta + 1;
321       locals = _prev_frame->locals();
322     }
323     VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(
324       THREAD, VerificationType, 2);
325     u2 stack_size = 1;
326     stack[0] = parse_verification_type(nullptr, CHECK_VERIFY_(_verifier, nullptr));
327     if (stack[0].is_category2()) {
328       stack[1] = stack[0].to_category2_2nd();
329       stack_size = 2;
330     }
331     check_verification_type_array_size(
332       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
333     frame = new StackMapFrame(
334       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
335       _max_locals, _max_stack, locals, stack, _verifier);

336     if (_first && locals != nullptr) {
337       frame->copy_locals(_prev_frame);
338     }
339     _first = false;
340     return frame;
341   }
342 
343   if (frame_type <= SAME_EXTENDED) {
344     // chop_frame or same_frame_extended
345     locals = _prev_frame->locals();
346     int length = _prev_frame->locals_size();
347     int chops = SAME_EXTENDED - frame_type;
348     int new_length = length;
349     u1 flags = _prev_frame->flags();
350     if (chops != 0) {
351       new_length = chop(locals, length, chops);
352       check_verification_type_array_size(
353         new_length, _max_locals, CHECK_VERIFY_(_verifier, nullptr));
354       // Recompute flags since uninitializedThis could have been chopped.
355       flags = 0;

357         if (locals[i].is_uninitialized_this()) {
358           flags |= FLAG_THIS_UNINIT;
359           break;
360         }
361       }
362     }
363     if (_first) {
364       offset = offset_delta;
365       // Can't share the locals array since that is updated by the verifier.
366       if (new_length > 0) {
367         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
368           THREAD, VerificationType, new_length);
369       } else {
370         locals = nullptr;
371       }
372     } else {
373       offset = _prev_frame->offset() + offset_delta + 1;
374     }
375     frame = new StackMapFrame(
376       offset, flags, new_length, 0, _max_locals, _max_stack,
377       locals, nullptr, _verifier);

378     if (_first && locals != nullptr) {
379       frame->copy_locals(_prev_frame);
380     }
381     _first = false;
382     return frame;
383   } else if (frame_type < SAME_EXTENDED + 4) {
384     // append_frame
385     int appends = frame_type - SAME_EXTENDED;
386     int real_length = _prev_frame->locals_size();
387     int new_length = real_length + appends*2;
388     locals = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, VerificationType, new_length);
389     VerificationType* pre_locals = _prev_frame->locals();
390     for (int i = 0; i < _prev_frame->locals_size(); i++) {
391       locals[i] = pre_locals[i];
392     }
393     u1 flags = _prev_frame->flags();
394     for (int i = 0; i < appends; i++) {
395       locals[real_length] = parse_verification_type(&flags, CHECK_NULL);
396       if (locals[real_length].is_category2()) {
397         locals[real_length + 1] = locals[real_length].to_category2_2nd();
398         ++real_length;
399       }
400       ++real_length;
401     }
402     check_verification_type_array_size(
403       real_length, _max_locals, CHECK_VERIFY_(_verifier, nullptr));
404     if (_first) {
405       offset = offset_delta;
406     } else {
407       offset = _prev_frame->offset() + offset_delta + 1;
408     }
409     frame = new StackMapFrame(
410       offset, flags, real_length, 0, _max_locals,
411       _max_stack, locals, nullptr, _verifier);

412     _first = false;
413     return frame;
414   }
415   if (frame_type == FULL) {
416     // full_frame
417     u1 flags = 0;
418     u2 locals_size = _stream->get_u2(CHECK_NULL);
419     int real_locals_size = 0;
420     if (locals_size > 0) {
421       locals = NEW_RESOURCE_ARRAY_IN_THREAD(
422         THREAD, VerificationType, locals_size*2);
423     }
424     for (int i = 0; i < locals_size; i++) {
425       locals[real_locals_size] = parse_verification_type(&flags, CHECK_NULL);
426       if (locals[real_locals_size].is_category2()) {
427         locals[real_locals_size + 1] =
428           locals[real_locals_size].to_category2_2nd();
429         ++real_locals_size;
430       }
431       ++real_locals_size;

439       stack = NEW_RESOURCE_ARRAY_IN_THREAD(
440         THREAD, VerificationType, stack_size*2);
441     }
442     for (int i = 0; i < stack_size; i++) {
443       stack[real_stack_size] = parse_verification_type(nullptr, CHECK_NULL);
444       if (stack[real_stack_size].is_category2()) {
445         stack[real_stack_size + 1] = stack[real_stack_size].to_category2_2nd();
446         ++real_stack_size;
447       }
448       ++real_stack_size;
449     }
450     check_verification_type_array_size(
451       real_stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
452     if (_first) {
453       offset = offset_delta;
454     } else {
455       offset = _prev_frame->offset() + offset_delta + 1;
456     }
457     frame = new StackMapFrame(
458       offset, flags, real_locals_size, real_stack_size,
459       _max_locals, _max_stack, locals, stack, _verifier);

460     _first = false;
461     return frame;
462   }
463 
464   _stream->stackmap_format_error(
465     "reserved frame type", CHECK_VERIFY_(_prev_frame->verifier(), nullptr));
466   return nullptr;
467 }

110   bool result = true;
111   if (match) {
112     // Has direct control flow from last instruction, need to match the two
113     // frames.
114     result = frame->is_assignable_to(stackmap_frame,
115         ctx, CHECK_VERIFY_(frame->verifier(), result));
116   }
117   if (update) {
118     // Use the frame in stackmap table as current frame
119     int lsize = stackmap_frame->locals_size();
120     int ssize = stackmap_frame->stack_size();
121     if (frame->locals_size() > lsize || frame->stack_size() > ssize) {
122       // Make sure unused type array items are all _bogus_type.
123       frame->reset();
124     }
125     frame->set_locals_size(lsize);
126     frame->copy_locals(stackmap_frame);
127     frame->set_stack_size(ssize);
128     frame->copy_stack(stackmap_frame);
129     frame->set_flags(stackmap_frame->flags());
130     frame->set_assert_unset_fields(stackmap_frame->assert_unset_fields());
131   }
132   return result;
133 }
134 
135 void StackMapTable::check_jump_target(
136     StackMapFrame* frame, int32_t target, TRAPS) const {
137   ErrorContext ctx;
138   bool match = match_stackmap(
139     frame, target, true, false, &ctx, CHECK_VERIFY(frame->verifier()));
140   if (!match || (target < 0 || target >= _code_length)) {
141     frame->verifier()->verify_error(ctx,
142         "Inconsistent stackmap frames at branch target %d", target);
143   }
144 }
145 
146 void StackMapTable::print_on(outputStream* str) const {
147   str->indent().print_cr("StackMapTable: frame_count = %d", _frame_count);
148   str->indent().print_cr("table = { ");
149   {
150     streamIndentor si(str);
151     for (int32_t i = 0; i < _frame_count; ++i) {
152       _frame_array->at(i)->print_on(str);
153     }
154   }
155   str->print_cr(" }");
156 }
157 
158 StackMapReader::StackMapReader(ClassVerifier* v, StackMapStream* stream,
159                                char* code_data, int32_t code_len,
160                                StackMapFrame* init_frame,
161                                u2 max_locals, u2 max_stack,
162                                StackMapFrame::AssertUnsetFieldTable* initial_strict_fields, TRAPS) :
163                                   _verifier(v), _stream(stream), _code_data(code_data),
164                                   _code_length(code_len), _parsed_frame_count(0),
165                                   _prev_frame(init_frame), _max_locals(max_locals),
166                                   _max_stack(max_stack), _assert_unset_fields_buffer(initial_strict_fields),
167                                   _first(true) {
168   methodHandle m = v->method();
169   if (m->has_stackmap_table()) {
170     _cp = constantPoolHandle(THREAD, m->constants());
171     _frame_count = _stream->get_u2(CHECK);
172   } else {
173     // There's no stackmap table present. Frame count and size are 0.
174     _frame_count = 0;
175   }
176 }
177 
178 int32_t StackMapReader::chop(
179     VerificationType* locals, int32_t length, int32_t chops) {
180   if (locals == nullptr) return -1;
181   int32_t pos = length - 1;
182   for (int32_t i=0; i<chops; i++) {
183     if (locals[pos].is_category2_2nd()) {
184       pos -= 2;
185     } else {
186       pos --;
187     }

189   }
190   return pos+1;
191 }
192 
193 #define CHECK_NT CHECK_(VerificationType::bogus_type())
194 
195 VerificationType StackMapReader::parse_verification_type(u1* flags, TRAPS) {
196   u1 tag = _stream->get_u1(CHECK_NT);
197   if (tag < (u1)ITEM_UninitializedThis) {
198     return VerificationType::from_tag(tag);
199   }
200   if (tag == ITEM_Object) {
201     u2 class_index = _stream->get_u2(CHECK_NT);
202     int nconstants = _cp->length();
203     if ((class_index <= 0 || class_index >= nconstants) ||
204         (!_cp->tag_at(class_index).is_klass() &&
205          !_cp->tag_at(class_index).is_unresolved_klass())) {
206       _stream->stackmap_format_error("bad class index", THREAD);
207       return VerificationType::bogus_type();
208     }
209     Symbol* klass_name = _cp->klass_name_at(class_index);
210     return VerificationType::reference_type(klass_name);
211   }
212   if (tag == ITEM_UninitializedThis) {
213     if (flags != nullptr) {
214       *flags |= FLAG_THIS_UNINIT;
215     }
216     return VerificationType::uninitialized_this_type();
217   }
218   if (tag == ITEM_Uninitialized) {
219     u2 offset = _stream->get_u2(CHECK_NT);
220     if (offset >= _code_length ||
221         _code_data[offset] != ClassVerifier::NEW_OFFSET) {
222       _verifier->class_format_error(
223         "StackMapTable format error: bad offset for Uninitialized");
224       return VerificationType::bogus_type();
225     }
226     return VerificationType::uninitialized_type(offset);
227   }
228   _stream->stackmap_format_error("bad verification type", THREAD);
229   return VerificationType::bogus_type();
230 }
231 
232 StackMapFrame* StackMapReader::next(TRAPS) {
233   _parsed_frame_count++;
234   check_size(CHECK_NULL);
235   StackMapFrame* frame = next_helper(CHECK_VERIFY_(_verifier, nullptr));
236   if (frame != nullptr) {
237     check_offset(frame);
238     if (frame->verifier()->has_error()) {
239       return nullptr;
240     }
241     _prev_frame = frame;
242   }
243   return frame;
244 }
245 
246 StackMapFrame* StackMapReader::next_helper(TRAPS) {
247   StackMapFrame* frame;
248   int offset;
249   VerificationType* locals = nullptr;
250   u1 frame_type = _stream->get_u1(CHECK_NULL);
251   if (frame_type == EARLY_LARVAL) {
252     u2 num_unset_fields = _stream->get_u2(CHECK_NULL);
253     StackMapFrame::AssertUnsetFieldTable* new_fields = new StackMapFrame::AssertUnsetFieldTable();
254 
255     for (u2 i = 0; i < num_unset_fields; i++) {
256       u2 index = _stream->get_u2(CHECK_NULL);
257 
258       if (!_cp->is_within_bounds(index) || !_cp->tag_at(index).is_name_and_type()) {
259         _prev_frame->verifier()->verify_error(
260           ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
261           "Invalid constant pool index in early larval frame: %d", index);
262         return nullptr;
263       }
264 
265       Symbol* name = _cp->symbol_at(_cp->name_ref_index_at(index));
266       Symbol* sig = _cp->symbol_at(_cp->signature_ref_index_at(index));
267       NameAndSig tmp(name, sig);
268 
269       if (!_prev_frame->assert_unset_fields()->contains(tmp)) {
270         log_info(verification)("NameAndType %s%s(CP index: %d) is not found among initial strict instance fields", name->as_C_string(), sig->as_C_string(), index);
271         StackMapFrame::print_strict_fields(_prev_frame->assert_unset_fields());
272         _prev_frame->verifier()->verify_error(
273             ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
274             "Strict fields not a subset of initial strict instance fields: %s:%s", name->as_C_string(), sig->as_C_string());
275         return nullptr;
276       } else {
277         new_fields->put(tmp, false);
278       }
279     }
280 
281     // Only modify strict instance fields the frame has uninitialized this
282     if (_prev_frame->flag_this_uninit()) {
283       _assert_unset_fields_buffer = _prev_frame->merge_unset_fields(new_fields);
284     } else if (new_fields->number_of_entries() > 0) {
285       _prev_frame->verifier()->verify_error(
286         ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
287         "Cannot have uninitialized strict fields after class initialization");
288       return nullptr;
289     }
290 
291     // Continue reading frame data
292     if (at_end()) {
293       _prev_frame->verifier()->verify_error(
294         ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
295         "Early larval frame must be followed by a base frame");
296       return nullptr;
297     }
298 
299     frame_type = _stream->get_u1(CHECK_NULL);
300     if (frame_type == EARLY_LARVAL) {
301       _prev_frame->verifier()->verify_error(
302         ErrorContext::bad_strict_fields(_prev_frame->offset(), _prev_frame),
303         "Early larval frame must be followed by a base frame");
304       return nullptr;
305     }
306   }
307 
308   if (frame_type < 64) {
309     // same_frame
310     if (_first) {
311       offset = frame_type;
312       // Can't share the locals array since that is updated by the verifier.
313       if (_prev_frame->locals_size() > 0) {
314         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
315           THREAD, VerificationType, _prev_frame->locals_size());
316       }
317     } else {
318       offset = _prev_frame->offset() + frame_type + 1;
319       locals = _prev_frame->locals();
320     }
321     frame = new StackMapFrame(
322       offset, _prev_frame->flags(), _prev_frame->locals_size(), 0,
323       _max_locals, _max_stack, locals, nullptr,
324       _assert_unset_fields_buffer, _verifier);
325     if (_first && locals != nullptr) {
326       frame->copy_locals(_prev_frame);
327     }
328     _first = false;
329     return frame;
330   }
331   if (frame_type < 128) {
332     // same_locals_1_stack_item_frame
333     if (_first) {
334       offset = frame_type - 64;
335       // Can't share the locals array since that is updated by the verifier.
336       if (_prev_frame->locals_size() > 0) {
337         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
338           THREAD, VerificationType, _prev_frame->locals_size());
339       }
340     } else {
341       offset = _prev_frame->offset() + frame_type - 63;
342       locals = _prev_frame->locals();
343     }
344     VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(
345       THREAD, VerificationType, 2);
346     u2 stack_size = 1;
347     stack[0] = parse_verification_type(nullptr, CHECK_VERIFY_(_verifier, nullptr));
348     if (stack[0].is_category2()) {
349       stack[1] = stack[0].to_category2_2nd();
350       stack_size = 2;
351     }
352     check_verification_type_array_size(
353       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
354     frame = new StackMapFrame(
355       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
356       _max_locals, _max_stack, locals, stack,
357       _assert_unset_fields_buffer, _verifier);
358     if (_first && locals != nullptr) {
359       frame->copy_locals(_prev_frame);
360     }
361     _first = false;
362     return frame;
363   }
364 
365   u2 offset_delta = _stream->get_u2(CHECK_NULL);
366 
367   if (frame_type < EARLY_LARVAL) {
368     // reserved frame types
369     _stream->stackmap_format_error(
370       "reserved frame type", CHECK_VERIFY_(_verifier, nullptr));
371   }
372 
373   if (frame_type == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
374     // same_locals_1_stack_item_frame_extended
375     if (_first) {
376       offset = offset_delta;
377       // Can't share the locals array since that is updated by the verifier.
378       if (_prev_frame->locals_size() > 0) {
379         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
380           THREAD, VerificationType, _prev_frame->locals_size());
381       }
382     } else {
383       offset = _prev_frame->offset() + offset_delta + 1;
384       locals = _prev_frame->locals();
385     }
386     VerificationType* stack = NEW_RESOURCE_ARRAY_IN_THREAD(
387       THREAD, VerificationType, 2);
388     u2 stack_size = 1;
389     stack[0] = parse_verification_type(nullptr, CHECK_VERIFY_(_verifier, nullptr));
390     if (stack[0].is_category2()) {
391       stack[1] = stack[0].to_category2_2nd();
392       stack_size = 2;
393     }
394     check_verification_type_array_size(
395       stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
396     frame = new StackMapFrame(
397       offset, _prev_frame->flags(), _prev_frame->locals_size(), stack_size,
398       _max_locals, _max_stack, locals, stack,
399       _assert_unset_fields_buffer, _verifier);
400     if (_first && locals != nullptr) {
401       frame->copy_locals(_prev_frame);
402     }
403     _first = false;
404     return frame;
405   }
406 
407   if (frame_type <= SAME_EXTENDED) {
408     // chop_frame or same_frame_extended
409     locals = _prev_frame->locals();
410     int length = _prev_frame->locals_size();
411     int chops = SAME_EXTENDED - frame_type;
412     int new_length = length;
413     u1 flags = _prev_frame->flags();
414     if (chops != 0) {
415       new_length = chop(locals, length, chops);
416       check_verification_type_array_size(
417         new_length, _max_locals, CHECK_VERIFY_(_verifier, nullptr));
418       // Recompute flags since uninitializedThis could have been chopped.
419       flags = 0;

421         if (locals[i].is_uninitialized_this()) {
422           flags |= FLAG_THIS_UNINIT;
423           break;
424         }
425       }
426     }
427     if (_first) {
428       offset = offset_delta;
429       // Can't share the locals array since that is updated by the verifier.
430       if (new_length > 0) {
431         locals = NEW_RESOURCE_ARRAY_IN_THREAD(
432           THREAD, VerificationType, new_length);
433       } else {
434         locals = nullptr;
435       }
436     } else {
437       offset = _prev_frame->offset() + offset_delta + 1;
438     }
439     frame = new StackMapFrame(
440       offset, flags, new_length, 0, _max_locals, _max_stack,
441       locals, nullptr,
442       _assert_unset_fields_buffer, _verifier);
443     if (_first && locals != nullptr) {
444       frame->copy_locals(_prev_frame);
445     }
446     _first = false;
447     return frame;
448   } else if (frame_type < SAME_EXTENDED + 4) {
449     // append_frame
450     int appends = frame_type - SAME_EXTENDED;
451     int real_length = _prev_frame->locals_size();
452     int new_length = real_length + appends*2;
453     locals = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, VerificationType, new_length);
454     VerificationType* pre_locals = _prev_frame->locals();
455     for (int i = 0; i < _prev_frame->locals_size(); i++) {
456       locals[i] = pre_locals[i];
457     }
458     u1 flags = _prev_frame->flags();
459     for (int i = 0; i < appends; i++) {
460       locals[real_length] = parse_verification_type(&flags, CHECK_NULL);
461       if (locals[real_length].is_category2()) {
462         locals[real_length + 1] = locals[real_length].to_category2_2nd();
463         ++real_length;
464       }
465       ++real_length;
466     }
467     check_verification_type_array_size(
468       real_length, _max_locals, CHECK_VERIFY_(_verifier, nullptr));
469     if (_first) {
470       offset = offset_delta;
471     } else {
472       offset = _prev_frame->offset() + offset_delta + 1;
473     }
474     frame = new StackMapFrame(
475       offset, flags, real_length, 0, _max_locals,
476       _max_stack, locals, nullptr,
477       _assert_unset_fields_buffer, _verifier);
478     _first = false;
479     return frame;
480   }
481   if (frame_type == FULL) {
482     // full_frame
483     u1 flags = 0;
484     u2 locals_size = _stream->get_u2(CHECK_NULL);
485     int real_locals_size = 0;
486     if (locals_size > 0) {
487       locals = NEW_RESOURCE_ARRAY_IN_THREAD(
488         THREAD, VerificationType, locals_size*2);
489     }
490     for (int i = 0; i < locals_size; i++) {
491       locals[real_locals_size] = parse_verification_type(&flags, CHECK_NULL);
492       if (locals[real_locals_size].is_category2()) {
493         locals[real_locals_size + 1] =
494           locals[real_locals_size].to_category2_2nd();
495         ++real_locals_size;
496       }
497       ++real_locals_size;

505       stack = NEW_RESOURCE_ARRAY_IN_THREAD(
506         THREAD, VerificationType, stack_size*2);
507     }
508     for (int i = 0; i < stack_size; i++) {
509       stack[real_stack_size] = parse_verification_type(nullptr, CHECK_NULL);
510       if (stack[real_stack_size].is_category2()) {
511         stack[real_stack_size + 1] = stack[real_stack_size].to_category2_2nd();
512         ++real_stack_size;
513       }
514       ++real_stack_size;
515     }
516     check_verification_type_array_size(
517       real_stack_size, _max_stack, CHECK_VERIFY_(_verifier, nullptr));
518     if (_first) {
519       offset = offset_delta;
520     } else {
521       offset = _prev_frame->offset() + offset_delta + 1;
522     }
523     frame = new StackMapFrame(
524       offset, flags, real_locals_size, real_stack_size,
525       _max_locals, _max_stack, locals, stack,
526       _assert_unset_fields_buffer, _verifier);
527     _first = false;
528     return frame;
529   }
530 
531   _stream->stackmap_format_error(
532     "reserved frame type", CHECK_VERIFY_(_prev_frame->verifier(), nullptr));
533   return nullptr;
534 }
< prev index next >