Mercurial > hg > graal-compiler
view src/cpu/zero/vm/compiledIC_zero.cpp @ 10953:97e282186b5b
Add heap sanity checker with premature hard crash for debugging write barriers
author | Christos Kotselidis <christos.kotselidis@oracle.com> |
---|---|
date | Fri, 02 Aug 2013 19:03:05 +0200 |
parents | a6e09d6dd8e5 |
children | c64b6b0c40c8 |
line wrap: on
line source
/* * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * 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/systemDictionary.hpp" #include "code/codeCache.hpp" #include "code/compiledIC.hpp" #include "code/icBuffer.hpp" #include "code/nmethod.hpp" #include "code/vtableStubs.hpp" #include "interpreter/interpreter.hpp" #include "interpreter/linkResolver.hpp" #include "memory/metadataFactory.hpp" #include "memory/oopFactory.hpp" #include "oops/method.hpp" #include "oops/oop.inline.hpp" #include "oops/symbol.hpp" #include "runtime/icache.hpp" #include "runtime/sharedRuntime.hpp" #include "runtime/stubRoutines.hpp" #include "utilities/events.hpp" // Release the CompiledICHolder* associated with this call site is there is one. void CompiledIC::cleanup_call_site(virtual_call_Relocation* call_site) { // This call site might have become stale so inspect it carefully. NativeCall* call = nativeCall_at(call_site->addr()); if (is_icholder_entry(call->destination())) { NativeMovConstReg* value = nativeMovConstReg_at(call_site->cached_value()); InlineCacheBuffer::queue_for_release((CompiledICHolder*)value->data()); } } bool CompiledIC::is_icholder_call_site(virtual_call_Relocation* call_site) { // This call site might have become stale so inspect it carefully. NativeCall* call = nativeCall_at(call_site->addr()); return is_icholder_entry(call->destination()); } //----------------------------------------------------------------------------- // High-level access to an inline cache. Guaranteed to be MT-safe. CompiledIC::CompiledIC(nmethod* nm, NativeCall* call) : _ic_call(call) { address ic_call = call->instruction_address(); assert(ic_call != NULL, "ic_call address must be set"); assert(nm != NULL, "must pass nmethod"); assert(nm->contains(ic_call), "must be in nmethod"); // Search for the ic_call at the given address. RelocIterator iter(nm, ic_call, ic_call+1); bool ret = iter.next(); assert(ret == true, "relocInfo must exist at this address"); assert(iter.addr() == ic_call, "must find ic_call"); if (iter.type() == relocInfo::virtual_call_type) { virtual_call_Relocation* r = iter.virtual_call_reloc(); _is_optimized = false; _value = nativeMovConstReg_at(r->cached_value()); } else { assert(iter.type() == relocInfo::opt_virtual_call_type, "must be a virtual call"); _is_optimized = true; _value = NULL; } } // ---------------------------------------------------------------------------- void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) { ShouldNotReachHere(); // Only needed for COMPILER2. } int CompiledStaticCall::to_interp_stub_size() { ShouldNotReachHere(); // Only needed for COMPILER2. return 0; } // Relocation entries for call stub, compiled java to interpreter. int CompiledStaticCall::reloc_to_interp_stub() { ShouldNotReachHere(); // Only needed for COMPILER2. return 0; } void CompiledStaticCall::set_to_interpreted(methodHandle callee, address entry) { ShouldNotReachHere(); // Only needed for COMPILER2. } void CompiledStaticCall::set_stub_to_clean(static_stub_Relocation* static_stub) { ShouldNotReachHere(); // Only needed for COMPILER2. } //----------------------------------------------------------------------------- // Non-product mode code. #ifndef PRODUCT void CompiledStaticCall::verify() { ShouldNotReachHere(); // Only needed for COMPILER2. } #endif // !PRODUCT