/*
* 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 "code/codeCache.hpp"
#include "code/debugInfoRec.hpp"
#include "code/nmethod.hpp"
#include "code/pcDesc.hpp"
#include "code/scopeDesc.hpp"
#include "interpreter/interpreter.hpp"
#include "interpreter/oopMapCache.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/basicLock.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/monitorChunk.hpp"
#include "runtime/signature.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/vframeArray.hpp"
#include "runtime/vframe_hp.hpp"
#ifdef COMPILER2
#include "opto/matcher.hpp"
#endif
// ------------- compiledVFrame --------------
// Natives has no scope
// scv_list is the list of ScopeValues describing the JVM stack state.
// There is one scv_list entry for every JVM stack state in use.
// In rare instances set_locals may have occurred in which case
// there are local values that are not described by the ScopeValue anymore
// In real life this never happens or is typically a single element search
break;
}
}
}
for( int i = 0; i < length; i++ ) {
}
// Replace specified locals with any deferred writes that are present
case T_BOOLEAN:
break;
case T_CHAR:
break;
case T_FLOAT:
break;
case T_DOUBLE:
break;
case T_BYTE:
break;
case T_SHORT:
break;
case T_INT:
break;
case T_LONG:
break;
case T_OBJECT:
{
}
break;
default:
}
}
}
return result;
}
fatal("Should use update_local for each local update");
}
#ifdef ASSERT
#endif /* ASSERT */
// See if this vframe has already had locals with deferred writes
int f;
// Matching, vframe now see if the local already had deferred write
int l;
return;
}
}
// No matching local already present. Push a new value onto the deferred collection
return;
}
}
// No matching vframe must push a new vframe
} else {
// No deferred updates pending for this thread.
// allocate in C heap
deferred = new(ResourceObj::C_HEAP, mtCompiler) GrowableArray<jvmtiDeferredLocalVariableSet*> (1, true);
}
}
// Natives has no scope
// scv_list is the list of ScopeValues describing the JVM stack state.
// There is one scv_list entry for every JVM stack state in use.
for( int i = 0; i < length; i++ )
return result;
}
// The implementation of the following two methods was factorized into the
// class StackValue because it is also used from within deoptimization.cpp for
// rematerialization and relocking of non-escaping objects.
}
}
// Natives has no scope
if (!method->is_synchronized()) {
return new GrowableArray<MonitorInfo*>(0);
}
// This monitor is really only needed for UseBiasedLocking, but
// return it in all cases for now as it might be useful for stack
// traces and tools as well
// Casting away const
return monitors;
}
return new GrowableArray<MonitorInfo*>(0);
}
if (ov->is_object() && owner_sv->obj_is_scalar_replaced()) { // The owner object was scalar replaced
// Put klass for scalar replaced object.
mv->eliminated(), true));
} else {
mv->eliminated(), false));
}
}
return result;
}
compiledVFrame::compiledVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread, nmethod* nm)
// Compiled method (native stub or Java code)
// native wrappers have no scope data, it is implied
if (!nm->is_native_method()) {
}
}
compiledVFrame::compiledVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread, ScopeDesc* scope)
}
// FIX IT: Remove this when new native stubs are in place
}
}
// native nmethods have no scope the method is implied
}
}
}
return 0;
}
}
return false;
}
return scope()->should_reexecute();
}
} else {
}
}
jvmtiDeferredLocalVariableSet::jvmtiDeferredLocalVariableSet(methodOop method, int bci, intptr_t* id) {
// Alway will need at least one, must be on C heap
_locals = new(ResourceObj::C_HEAP, mtCompiler) GrowableArray<jvmtiDeferredLocalVariable*> (1, true);
}
}
// Free growableArray and c heap for elements
delete _locals;
}
if (!vf->is_compiled_frame()) return false;
}
int i;
return;
}
}
}
}
}
}
}
#ifndef PRODUCT
}
#endif // PRODUCT