/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "precompiled.hpp"
#include "classfile/stackMapFrame.hpp"
#include "classfile/verifier.hpp"
#include "memory/resourceArea.hpp"
#include "oops/oop.inline.hpp"
#include "oops/symbol.hpp"
#include "runtime/handles.inline.hpp"
#include "utilities/globalDefinitions.hpp"
int32_t i;
for(i = 0; i < max_locals; i++) {
}
for(i = 0; i < max_stack; i++) {
}
}
StackMapFrame* frame = new StackMapFrame(_offset, flags, _locals_size, 0, _max_locals, _max_stack, _locals, stack, _verifier);
return frame;
}
int32_t i;
for (i = 0; i < _max_locals; i++) {
if (_locals[i].is_uninitialized()) {
return true;
}
}
for (i = 0; i < _stack_size; i++) {
if (_stack[i].is_uninitialized()) {
return true;
}
}
return false;
}
int32_t i;
for (i = 0; i < _max_locals; i++) {
_locals[i] = new_object;
}
}
for (i = 0; i < _stack_size; i++) {
_stack[i] = new_object;
}
}
// "this" has been initialized - reset flags
_flags = 0;
}
}
int init_local_num = 0;
if (!m->is_static()) {
// add one extra argument for instance method
} else {
}
}
while(!ss.at_return_type()) {
}
case T_OBJECT:
case T_ARRAY:
{
// Create another symbol to save as signature stream unreferences
// this symbol.
}
default:
}
return VerificationType::bogus_type();
}
}
}
}
}
// Returns the location of the first mismatch, or 'len' if there are no
// mismatches
int32_t i = 0;
for (i = 0; i < len; i++) {
break;
}
}
return i;
}
const StackMapFrame* target) const {
// We allow flags of {UninitThis} to assign to {} if-and-only-if the
// target frame does not depend upon the current type.
// This is slightly too strict, as we need only enforce that the
// slots that were initialized by the <init> (the things that were
// UninitializedThis before initialize_object() converted them) are unused.
// However we didn't save that information so we'll enforce this upon
// anything that might have been initialized. This is a rare situation
// and javac never generates code that would end up here, but some profilers
// (such as NetBeans) might, when adding exception handlers in <init>
// methods to cover the invokespecial instruction. See 7020118.
return false;
}
for (int i = 0; i < target->locals_size(); ++i) {
return false;
}
}
for (int i = 0; i < target->stack_size(); ++i) {
return false;
}
}
return true;
}
return false;
}
return false;
}
// Only need to compare type elements up to target->locals() or target->stack().
// The remaining type elements in this state can be ignored because they are
// assignable to bogus type.
int mismatch_loc;
return false;
}
if (mismatch_loc != _stack_size) {
return false;
}
return true;
} else {
return false;
}
}
if (_stack_size <= 0) {
verifier()->verify_error(
"Operand stack underflow");
return VerificationType::bogus_type();
}
if (!subtype) {
verifier()->verify_error(
"Bad type on operand stack");
return VerificationType::bogus_type();
}
return top;
}
if (index >= _max_locals) {
verifier()->verify_error(
"Local variable table overflow");
return VerificationType::bogus_type();
}
if (!subtype) {
verifier()->verify_error(
"Bad local variable type");
return VerificationType::bogus_type();
}
}
verifier()->verify_error(
return;
}
if (!subtype) {
verifier()->verify_error(
"Bad local variable type");
} else {
if (!subtype) {
/* Unreachable? All local store routines convert a split long or double
* into a TOP during the store. So we should never end up seeing an
* orphaned half. */
verifier()->verify_error(
"Bad local variable type");
}
}
}
if (index >= _max_locals) {
verifier()->verify_error(
"Local variable table overflow");
return;
}
// If type at index is double or long, set the next location to be unusable
}
// If type at index is double_2 or long_2, set the previous location to be unusable
}
if (index >= _locals_size) {
#ifdef ASSERT
for (int i=_locals_size; i<index; i++) {
"holes must be bogus type");
}
#endif
}
}
verifier()->verify_error(
"Local variable table overflow");
return;
}
// If type at index+1 is double or long, set the next location to be unusable
}
// If type at index is double_2 or long_2, set the previous location to be unusable
}
#ifdef ASSERT
for (int i=_locals_size; i<index; i++) {
"holes must be bogus type");
}
#endif
}
}
}
for (int32_t i = 0; i < _locals_size; ++i) {
if (i != _locals_size - 1) {
}
}
for (int32_t j = 0; j < _stack_size; ++j) {
if (j != _stack_size - 1) {
}
}
}