compiledIC.hpp

/*
 * Copyright (c) 1997, 2024, 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.
 *
*/

#ifndef SHARE_CODE_COMPILEDIC_HPP
#defineSHARE_CODE_COMPILEDIC_HPP

#include"code/nativeInst.hpp"
#include"interpreter/linkResolver.hpp"
#include"runtime/safepointVerifiers.hpp"

//-----------------------------------------------------------------------------
// The CompiledIC represents a compiled inline cache.
//
// It's safe to transition from any state to any state. Typically an inline cache starts
// in the clean state, meaning it will resolve the call when called. Then it typically
// transitions to monomorphic, assuming the first dynamic receiver will be the only one
// observed. If that speculation fails, we transition to megamorphic.
//
classCompiledIC;
classCompiledICProtectionBehaviour;
classnmethod;

classCompiledICLocker: publicStackObj {
 nmethod* _method;
 CompiledICProtectionBehaviour* _behaviour;
bool _locked;
 NoSafepointVerifier _nsv;

public:
CompiledICLocker(nmethod* method);
~CompiledICLocker();
staticboolis_safe(nmethod* method);
staticboolis_safe(address code);
};

// A CompiledICData is a helper object for the inline cache implementation.
// It comprises:
// (1) The first receiver klass and its selected method
// (2) Itable call metadata

classCompiledICData : publicCHeapObj<mtCode> {
friendclassVMStructs;
friendclassJVMCIVMStructs;

 Method* volatile _speculated_method;
uintptr_tvolatile _speculated_klass;
 Klass* _itable_defc_klass;
 Klass* _itable_refc_klass;
bool _is_initialized;

boolis_speculated_klass_unloaded() const;

public:
// Constructor
CompiledICData();

// accessors
 Klass* speculated_klass() const;
 Method* speculated_method() const { return _speculated_method; }
 Klass* itable_defc_klass() const { return _itable_defc_klass; }
 Klass* itable_refc_klass() const { return _itable_refc_klass; }

static ByteSize speculated_method_offset() { returnbyte_offset_of(CompiledICData, _speculated_method); }
static ByteSize speculated_klass_offset() { returnbyte_offset_of(CompiledICData, _speculated_klass); }

static ByteSize itable_defc_klass_offset() { returnbyte_offset_of(CompiledICData, _itable_defc_klass); }
static ByteSize itable_refc_klass_offset() { returnbyte_offset_of(CompiledICData, _itable_refc_klass); }

voidinitialize(CallInfo* call_info, Klass* receiver_klass);

boolis_initialized() const { return _is_initialized; }

// GC Support
voidclean_metadata();
voidmetadata_do(MetadataClosure* cl);
};

classCompiledIC: publicResourceObj {
private:
 nmethod* _method;
 CompiledICData* _data;
 NativeCall* _call;

CompiledIC(RelocIterator* iter);

// CompiledICData wrappers
voidensure_initialized(CallInfo* call_info, Klass* receiver_klass);
boolis_speculated_klass(Klass* receiver_klass);

// Inline cache states
voidset_to_monomorphic();
voidset_to_megamorphic(CallInfo* call_info);

public:
// conversion (machine PC to CompiledIC*)
friend CompiledIC* CompiledIC_before(nmethod* nm, address return_addr);
friend CompiledIC* CompiledIC_at(nmethod* nm, address call_site);
friend CompiledIC* CompiledIC_at(Relocation* call_site);
friend CompiledIC* CompiledIC_at(RelocIterator* reloc_iter);

 CompiledICData* data() const;

// State
boolis_clean() const;
boolis_monomorphic() const;
boolis_megamorphic() const;

 address end_of_call() const { return _call->return_address(); }

// MT-safe patching of inline caches. Note: Only safe to call is_xxx when holding the CompiledICLocker
// so you are guaranteed that no patching takes place. The same goes for verify.
voidset_to_clean();
voidupdate(CallInfo* call_info, Klass* receiver_klass);

// GC support
voidclean_metadata();
voidmetadata_do(MetadataClosure* cl);

// Location
 address instruction_address() const { return _call->instruction_address(); }
 address destination() const { return _call->destination(); }

// Misc
voidprint() PRODUCT_RETURN;
voidverify() PRODUCT_RETURN;
};

CompiledIC* CompiledIC_before(nmethod* nm, address return_addr);
CompiledIC* CompiledIC_at(nmethod* nm, address call_site);
CompiledIC* CompiledIC_at(Relocation* call_site);
CompiledIC* CompiledIC_at(RelocIterator* reloc_iter);

//-----------------------------------------------------------------------------
// The CompiledDirectCall represents a call to a method in the compiled code
//
//
// -----<----- Clean ----->-----
// / \
// / \
// compilled code <------------> interpreted code
//
// Clean: Calls directly to runtime method for fixup
// Compiled code: Calls directly to compiled code
// Interpreted code: Calls to stub that set Method* reference
//
//

classCompiledDirectCall : publicResourceObj {
private:
friendclassCompiledIC;
friendclassDirectNativeCallWrapper;

// Also used by CompiledIC
voidset_to_interpreted(const methodHandle& callee, address entry);
voidverify_mt_safe(const methodHandle& callee, address entry,
 NativeMovConstReg* method_holder,
 NativeJump* jump) PRODUCT_RETURN;
 address instruction_address() const { return _call->instruction_address(); }
voidset_destination_mt_safe(address dest) { _call->set_destination_mt_safe(dest); }

 NativeCall* _call;

CompiledDirectCall(NativeCall* call) : _call(call) {}

public:
// Returns null if CodeBuffer::expand fails
static address emit_to_interp_stub(MacroAssembler *masm, address mark = nullptr);
staticintto_interp_stub_size();
staticintto_trampoline_stub_size();
staticintreloc_to_interp_stub();

staticinline CompiledDirectCall* before(address return_addr) {
 CompiledDirectCall* st = newCompiledDirectCall(nativeCall_before(return_addr));
 st->verify();
return st;
 }

staticinline CompiledDirectCall* at(address native_call) {
 CompiledDirectCall* st = newCompiledDirectCall(nativeCall_at(native_call));
 st->verify();
return st;
 }

staticinline CompiledDirectCall* at(Relocation* call_site) {
returnat(call_site->addr());
 }

// Delegation
 address destination() const { return _call->destination(); }
 address end_of_call() const { return _call->return_address(); }

// Clean static call (will force resolving on next use)
voidset_to_clean();

voidset(const methodHandle& callee_method);

// State
boolis_clean() const;
boolis_call_to_interpreted() const;
boolis_call_to_compiled() const;

// Stub support
static address find_stub_for(address instruction);
 address find_stub();
staticvoidset_stub_to_clean(static_stub_Relocation* static_stub);

// Misc.
voidprint() PRODUCT_RETURN;
voidverify() PRODUCT_RETURN;
};

#endif// SHARE_CODE_COMPILEDIC_HPP