archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 06:45:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8303415: Add VM_Version::is_intrinsic_supported(id)

Browse source 
Reviewed-by: thartmann, dholmes
This commit is contained in:
Vladimir Kozlov 2023-03-14 12:20:14 +00:00
parent 31680b2bcf
commit ec1eb00ed3
25 changed files with 851 additions and 829 deletions
Download patch file Download diff file Expand all files Collapse all files

33
src/hotspot/cpu/aarch64/templateInterpreterGenerator_aarch64.cpp
View file

@ -146,8 +146,6 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
// r19_sender_sp: sender sp
// esp: args
if (!InlineIntrinsics) return NULL; // Generate a vanilla entry
// These don't need a safepoint check because they aren't virtually
// callable. We won't enter these intrinsics from compiled code.
// If in the future we added an intrinsic which was virtually callable
@ -301,12 +299,7 @@ void TemplateInterpreterGenerator::generate_transcendental_entry(AbstractInterpr
}
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16)) {
return nullptr;
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
// r19_sender_sp: sender sp
// stack:
// [ arg ] <-- esp
@ -323,12 +316,7 @@ address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
}
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16)) {
return nullptr;
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
// r19_sender_sp: sender sp
// stack:
// [ arg ] <-- esp
@ -963,7 +951,7 @@ address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {
* int java.util.zip.CRC32.update(int crc, int b)
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rmethod: Method*
@ -1004,8 +992,6 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for static native methods:
@ -1013,7 +999,7 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
* int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rmethod,: Method*
@ -1059,8 +1045,6 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for intrinsic-candidate (non-native) methods:
@ -1070,7 +1054,7 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
* CRC32C also uses an "end" variable instead of the length variable CRC32 uses
*/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32CIntrinsics) {
assert(UseCRC32CIntrinsics, "this intrinsic is not supported");
address entry = __ pc();
// Prepare jump to stub using parameters from the stack
@ -1100,8 +1084,6 @@ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(Abstract
return entry;
}
return NULL;
}
void TemplateInterpreterGenerator::bang_stack_shadow_pages(bool native_call) {
// See more discussion in stackOverflow.hpp.
@ -1742,6 +1724,11 @@ address TemplateInterpreterGenerator::generate_currentThread() {
return entry_point;
}
// Not supported
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }
//-----------------------------------------------------------------------------
// Exceptions

7
src/hotspot/cpu/arm/templateInterpreterGenerator_arm.cpp
View file

@ -122,8 +122,6 @@ address TemplateInterpreterGenerator::generate_abstract_entry(void) {
}
address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {
if (!InlineIntrinsics) return nullptr; // Generate a vanilla entry
address entry_point = nullptr;
Register continuation = LR;
bool use_runtime_call = false;
@ -780,9 +778,14 @@ address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {
}
// Not supported
address TemplateInterpreterGenerator::generate_currentThread() { return nullptr; }
address TemplateInterpreterGenerator::generate_CRC32_update_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) { return nullptr; }
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() { return nullptr; }

20
src/hotspot/cpu/ppc/templateInterpreterGenerator_ppc.cpp
View file

@ -1746,7 +1746,7 @@ address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
* int java.util.zip.CRC32.update(int crc, int b)
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address start = __ pc(); // Remember stub start address (is rtn value).
Label slow_path;
@ -1791,16 +1791,13 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
return start;
}
return NULL;
}
/**
* Method entry for static native methods:
* int java.util.zip.CRC32.updateBytes( int crc, byte[] b, int off, int len)
* int java.util.zip.CRC32.updateByteBuffer(int crc, long* buf, int off, int len)
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address start = __ pc(); // Remember stub start address (is rtn value).
Label slow_path;
@ -1862,9 +1859,6 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
return start;
}
return NULL;
}
/**
* Method entry for intrinsic-candidate (non-native) methods:
@ -1874,7 +1868,7 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
* CRC32C also uses an "end" variable instead of the length variable CRC32 uses
**/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32CIntrinsics) {
assert(UseCRC32CIntrinsics, "this intrinsic is not supported");
address start = __ pc(); // Remember stub start address (is rtn value).
// We don't generate local frame and don't align stack because
@ -1930,10 +1924,12 @@ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(Abstract
return start;
}
return NULL;
}
// Not supported
address TemplateInterpreterGenerator::generate_currentThread() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() { return nullptr; }

22
src/hotspot/cpu/riscv/templateInterpreterGenerator_riscv.cpp
View file

@ -143,10 +143,6 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
// x19_sender_sp: sender sp
// esp: args
if (!InlineIntrinsics) {
return NULL; // Generate a vanilla entry
}
// These don't need a safepoint check because they aren't virtually
// callable. We won't enter these intrinsics from compiled code.
// If in the future we added an intrinsic which was virtually callable
@ -301,10 +297,6 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
return entry_point;
}
// Not supported
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() { return nullptr; }
// Abstract method entry
// Attempt to execute abstract method. Throw exception
address TemplateInterpreterGenerator::generate_abstract_entry(void) {
@ -864,7 +856,7 @@ address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
// TODO: Unimplemented generate_CRC32_update_entry
return 0;
return nullptr;
}
/**
@ -874,7 +866,7 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
// TODO: Unimplemented generate_CRC32_updateBytes_entry
return 0;
return nullptr;
}
/**
@ -886,9 +878,17 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
*/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
// TODO: Unimplemented generate_CRC32C_updateBytes_entry
return 0;
return nullptr;
}
// Not supported
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() { return nullptr; }
void TemplateInterpreterGenerator::bang_stack_shadow_pages(bool native_call) {
// See more discussion in stackOverflow.hpp.

23
src/hotspot/cpu/s390/templateInterpreterGenerator_s390.cpp
View file

@ -1801,8 +1801,7 @@ address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
* int java.util.zip.CRC32.update(int crc, int b)
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
uint64_t entry_off = __ offset();
Label slow_path;
@ -1844,9 +1843,6 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
return __ addr_at(entry_off);
}
return NULL;
}
/**
* Method entry for static native methods:
@ -1854,8 +1850,7 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
* int java.util.zip.CRC32.updateByteBuffer(int crc, long* buf, int off, int len)
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
uint64_t entry_off = __ offset();
Label slow_path;
@ -1924,9 +1919,6 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
return __ addr_at(entry_off);
}
return NULL;
}
/**
* Method entry for intrinsic-candidate (non-native) methods:
@ -1936,8 +1928,7 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
* CRC32C also uses an "end" variable instead of the length variable CRC32 uses
*/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32CIntrinsics) {
assert(UseCRC32CIntrinsics, "this intrinsic is not supported");
uint64_t entry_off = __ offset();
// We don't generate local frame and don't align stack because
@ -2000,10 +1991,12 @@ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(Abstract
return __ addr_at(entry_off);
}
return NULL;
}
// Not supported
address TemplateInterpreterGenerator::generate_currentThread() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() { return nullptr; }

32
src/hotspot/cpu/x86/templateInterpreterGenerator_x86_32.cpp
View file

@ -53,7 +53,7 @@ address TemplateInterpreterGenerator::generate_slow_signature_handler() {
* int java.util.zip.CRC32.update(int crc, int b)
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rbx: Method*
@ -94,8 +94,6 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for static native methods:
@ -103,7 +101,7 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
* int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rbx,: Method*
@ -158,8 +156,6 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for static native methods:
@ -167,7 +163,7 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
* int java.util.zip.CRC32C.updateByteBuffer(int crc, long address, int off, int end)
*/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32CIntrinsics) {
assert(UseCRC32CIntrinsics, "this intrinsic is not supported");
address entry = __ pc();
// Load parameters
const Register crc = rax; // crc
@ -205,8 +201,6 @@ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(Abstract
return entry;
}
return NULL;
}
/**
* Method entry for static native method:
@ -319,12 +313,7 @@ address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry(
* java.lang.Float.float16ToFloat(short floatBinary16)
*/
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16)) {
return nullptr; // Generate a vanilla entry
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
address entry = __ pc();
// rsi: the sender's SP
@ -345,12 +334,7 @@ address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
* java.lang.Float.floatToFloat16(float value)
*/
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat)) {
return nullptr; // Generate a vanilla entry
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
address entry = __ pc();
// rsi: the sender's SP
@ -372,8 +356,6 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
// rcx: scratrch
// rsi: sender sp
if (!InlineIntrinsics) return NULL; // Generate a vanilla entry
address entry_point = __ pc();
// These don't need a safepoint check because they aren't virtually
@ -518,3 +500,7 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
return entry_point;
}
// Not supported
address TemplateInterpreterGenerator::generate_currentThread() { return nullptr; }

35
src/hotspot/cpu/x86/templateInterpreterGenerator_x86_64.cpp
View file

@ -182,7 +182,7 @@ address TemplateInterpreterGenerator::generate_slow_signature_handler() {
* int java.util.zip.CRC32.update(int crc, int b)
*/
address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rbx,: Method*
@ -221,8 +221,6 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for static native methods:
@ -230,7 +228,7 @@ address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
* int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len)
*/
address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32Intrinsics) {
assert(UseCRC32Intrinsics, "this intrinsic is not supported");
address entry = __ pc();
// rbx,: Method*
@ -278,8 +276,6 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
__ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native));
return entry;
}
return NULL;
}
/**
* Method entry for static (non-native) methods:
@ -287,7 +283,7 @@ address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractI
* int java.util.zip.CRC32C.updateDirectByteBuffer(int crc, long address, int off, int end)
*/
address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
if (UseCRC32CIntrinsics) {
assert(UseCRC32CIntrinsics, "this intrinsic is not supported");
address entry = __ pc();
// Load parameters
const Register crc = c_rarg0; // crc
@ -329,20 +325,12 @@ address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(Abstract
return entry;
}
return NULL;
}
/**
* Method entry for static method:
* java.lang.Float.float16ToFloat(short floatBinary16)
*/
address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16)) {
return nullptr; // Generate a vanilla entry
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
address entry = __ pc();
// r13: the sender's SP
@ -364,12 +352,7 @@ address TemplateInterpreterGenerator::generate_Float_float16ToFloat_entry() {
* java.lang.Float.floatToFloat16(float value)
*/
address TemplateInterpreterGenerator::generate_Float_floatToFloat16_entry() {
// vmIntrinsics checks InlineIntrinsics flag, no need to check it here.
if (!VM_Version::supports_float16() ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_floatToFloat16) ||
vmIntrinsics::is_disabled_by_flags(vmIntrinsics::_float16ToFloat)) {
return nullptr; // Generate a vanilla entry
}
assert(VM_Version::supports_float16(), "this intrinsic is not supported");
address entry = __ pc();
// r13: the sender's SP
@ -396,8 +379,6 @@ address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::M
// rcx: scratrch
// r13: sender sp
if (!InlineIntrinsics) return NULL; // Generate a vanilla entry
address entry_point = __ pc();
// These don't need a safepoint check because they aren't virtually
@ -514,3 +495,9 @@ address TemplateInterpreterGenerator::generate_currentThread() {
return entry_point;
}
// Not supported
address TemplateInterpreterGenerator::generate_Float_intBitsToFloat_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Float_floatToRawIntBits_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_longBitsToDouble_entry() { return nullptr; }
address TemplateInterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { return nullptr; }

17
src/hotspot/cpu/x86/vm_version_x86.cpp
View file

@ -25,6 +25,7 @@
#include "precompiled.hpp"
#include "asm/macroAssembler.hpp"
#include "asm/macroAssembler.inline.hpp"
#include "classfile/vmIntrinsics.hpp"
#include "code/codeBlob.hpp"
#include "compiler/compilerDefinitions.inline.hpp"
#include "jvm.h"
@ -3220,3 +3221,19 @@ intx VM_Version::allocate_prefetch_distance(bool use_watermark_prefetch) {
}
}
}
bool VM_Version::is_intrinsic_supported(vmIntrinsicID id) {
assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
switch (id) {
case vmIntrinsics::_floatToFloat16:
case vmIntrinsics::_float16ToFloat:
if (!supports_float16()) {
return false;
}
break;
default:
break;
}
return true;
}

3
src/hotspot/cpu/x86/vm_version_x86.hpp
View file

@ -764,6 +764,9 @@ public:
return supports_f16c() || supports_avx512vl();
}
// Check intrinsic support
static bool is_intrinsic_supported(vmIntrinsicID id);
// there are several insns to force cache line sync to memory which
// we can use to ensure mapped non-volatile memory is up to date with
// pending in-cache changes.

6
src/hotspot/share/classfile/vmIntrinsics.cpp
View file

@ -28,6 +28,7 @@
#include "compiler/compilerDirectives.hpp"
#include "jvm_constants.h"
#include "jvm_io.h"
#include "runtime/vm_version.hpp"
#include "utilities/xmlstream.hpp"
// These are flag-matching functions:
@ -649,9 +650,8 @@ vmIntrinsics::ID vmIntrinsics::find_id(const char* name) {
return _none;
}
bool vmIntrinsics::is_disabled_by_flags(const methodHandle& method) {
vmIntrinsics::ID id = method->intrinsic_id();
return is_disabled_by_flags(id);
bool vmIntrinsics::is_intrinsic_available(vmIntrinsics::ID id) {
return VM_Version::is_intrinsic_supported(id) && !is_disabled_by_flags(id);
}
bool vmIntrinsics::is_disabled_by_flags(vmIntrinsics::ID id) {

5
src/hotspot/share/classfile/vmIntrinsics.hpp
View file

@ -1524,10 +1524,7 @@ public:
// the corresponding coarse-grained control(2) disables it.
static bool is_disabled_by_flags(vmIntrinsics::ID id);
static bool is_disabled_by_flags(const methodHandle& method);
static bool is_intrinsic_available(vmIntrinsics::ID id) {
return !is_disabled_by_flags(id);
}
static bool is_intrinsic_available(vmIntrinsics::ID id);
};
#undef VM_INTRINSIC_ENUM

6
src/hotspot/share/compiler/abstractCompiler.hpp
View file

@ -126,9 +126,11 @@ class AbstractCompiler : public CHeapObj<mtCompiler> {
// for more details.
bool is_intrinsic_available(const methodHandle& method, DirectiveSet* directive) {
vmIntrinsics::ID id = method->intrinsic_id();
assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
return is_intrinsic_supported(method) &&
!directive->is_intrinsic_disabled(method) &&
!vmIntrinsics::is_disabled_by_flags(method);
vmIntrinsics::is_intrinsic_available(id) &&
!directive->is_intrinsic_disabled(id);
}
// Determines if an intrinsic is supported by the compiler, that is,

3
src/hotspot/share/compiler/compilerDirectives.cpp
View file

@ -549,8 +549,7 @@ void DirectiveSet::print_inline(outputStream* st) {
}
}
bool DirectiveSet::is_intrinsic_disabled(const methodHandle& method) {
vmIntrinsics::ID id = method->intrinsic_id();
bool DirectiveSet::is_intrinsic_disabled(vmIntrinsics::ID id) {
assert(id > vmIntrinsics::_none && id < vmIntrinsics::ID_LIMIT, "invalid intrinsic_id!");
TriBool b = _intrinsic_control_words[vmIntrinsics::as_int(id)];

2
src/hotspot/share/compiler/compilerDirectives.hpp
View file

@ -126,7 +126,7 @@ public:
bool is_exclusive_copy() { return _directive == nullptr; }
bool matches_inline(const methodHandle& method, int inline_action);
static DirectiveSet* clone(DirectiveSet const* src);
bool is_intrinsic_disabled(const methodHandle& method);
bool is_intrinsic_disabled(vmIntrinsicID id);
static ccstrlist canonicalize_control_intrinsic(ccstrlist option_value);
void finalize(outputStream* st);
bool is_c1(CompilerDirectives* directive) const;

67
src/hotspot/share/interpreter/abstractInterpreter.cpp
View file

@ -87,8 +87,6 @@ StubQueue* AbstractInterpreter::_code = nu
bool AbstractInterpreter::_notice_safepoints = false;
address AbstractInterpreter::_rethrow_exception_entry = nullptr;
address AbstractInterpreter::_native_entry_begin = nullptr;
address AbstractInterpreter::_native_entry_end = nullptr;
address AbstractInterpreter::_slow_signature_handler;
address AbstractInterpreter::_entry_table [AbstractInterpreter::number_of_method_entries];
address AbstractInterpreter::_native_abi_to_tosca [AbstractInterpreter::number_of_result_handlers];
@ -135,9 +133,7 @@ AbstractInterpreter::MethodKind AbstractInterpreter::method_kind(const methodHan
case vmIntrinsics::_doubleToRawLongBits: return java_lang_Double_doubleToRawLongBits;
case vmIntrinsics::_float16ToFloat: return java_lang_Float_float16ToFloat;
case vmIntrinsics::_floatToFloat16: return java_lang_Float_floatToFloat16;
#if defined(AMD64) || defined(AARCH64) || defined(RISCV64)
case vmIntrinsics::_currentThread: return java_lang_Thread_currentThread;
#endif
#endif // ZERO
case vmIntrinsics::_dsin: return java_lang_math_sin;
case vmIntrinsics::_dcos: return java_lang_math_cos;
@ -150,7 +146,7 @@ AbstractInterpreter::MethodKind AbstractInterpreter::method_kind(const methodHan
case vmIntrinsics::_fmaD: return java_lang_math_fmaD;
case vmIntrinsics::_fmaF: return java_lang_math_fmaF;
case vmIntrinsics::_dsqrt: return java_lang_math_sqrt;
case vmIntrinsics::_dsqrt_strict: return java_lang_math_sqrt;
case vmIntrinsics::_dsqrt_strict: return java_lang_math_sqrt_strict;
case vmIntrinsics::_Reference_get: return java_lang_ref_reference_get;
case vmIntrinsics::_Object_init:
if (RegisterFinalizersAtInit && m->code_size() == 1) {
@ -197,7 +193,53 @@ AbstractInterpreter::MethodKind AbstractInterpreter::method_kind(const methodHan
return zerolocals;
}
void AbstractInterpreter::set_entry_for_kind(AbstractInterpreter::MethodKind kind, address entry) {
vmIntrinsics::ID AbstractInterpreter::method_intrinsic(MethodKind kind) {
switch (kind) {
case java_lang_math_sin : return vmIntrinsics::_dsin;
case java_lang_math_cos : return vmIntrinsics::_dcos;
case java_lang_math_tan : return vmIntrinsics::_dtan;
case java_lang_math_abs : return vmIntrinsics::_dabs;
case java_lang_math_log : return vmIntrinsics::_dlog;
case java_lang_math_log10 : return vmIntrinsics::_dlog10;
case java_lang_math_sqrt : return vmIntrinsics::_dsqrt;
case java_lang_math_sqrt_strict : return vmIntrinsics::_dsqrt_strict;
case java_lang_math_pow : return vmIntrinsics::_dpow;
case java_lang_math_exp : return vmIntrinsics::_dexp;
case java_lang_math_fmaD : return vmIntrinsics::_fmaD;
case java_lang_math_fmaF : return vmIntrinsics::_fmaF;
case java_lang_ref_reference_get: return vmIntrinsics::_Reference_get;
case java_util_zip_CRC32_update : return vmIntrinsics::_updateCRC32;
case java_util_zip_CRC32_updateBytes
: return vmIntrinsics::_updateBytesCRC32;
case java_util_zip_CRC32_updateByteBuffer
: return vmIntrinsics::_updateByteBufferCRC32;
case java_util_zip_CRC32C_updateBytes
: return vmIntrinsics::_updateBytesCRC32C;
case java_util_zip_CRC32C_updateDirectByteBuffer
: return vmIntrinsics::_updateDirectByteBufferCRC32C;
case java_lang_Thread_currentThread
: return vmIntrinsics::_currentThread;
case java_lang_Float_intBitsToFloat
: return vmIntrinsics::_intBitsToFloat;
case java_lang_Float_floatToRawIntBits
: return vmIntrinsics::_floatToRawIntBits;
case java_lang_Double_longBitsToDouble
: return vmIntrinsics::_longBitsToDouble;
case java_lang_Double_doubleToRawLongBits
: return vmIntrinsics::_doubleToRawLongBits;
case java_lang_Float_float16ToFloat
: return vmIntrinsics::_float16ToFloat;
case java_lang_Float_floatToFloat16
: return vmIntrinsics::_floatToFloat16;
default:
fatal("unexpected method intrinsic kind: %d", kind);
break;
}
return vmIntrinsics::_none;
}
void AbstractInterpreter::set_entry_for_kind(MethodKind kind, address entry) {
assert(kind >= method_handle_invoke_FIRST &&
kind <= method_handle_invoke_LAST, "late initialization only for MH entry points");
assert(_entry_table[kind] == _entry_table[abstract], "previous value must be AME entry");
@ -268,16 +310,27 @@ void AbstractInterpreter::print_method_kind(MethodKind kind) {
case java_lang_math_cos : tty->print("java_lang_math_cos" ); break;
case java_lang_math_tan : tty->print("java_lang_math_tan" ); break;
case java_lang_math_abs : tty->print("java_lang_math_abs" ); break;
case java_lang_math_sqrt : tty->print("java_lang_math_sqrt" ); break;
case java_lang_math_log : tty->print("java_lang_math_log" ); break;
case java_lang_math_log10 : tty->print("java_lang_math_log10" ); break;
case java_lang_math_pow : tty->print("java_lang_math_pow" ); break;
case java_lang_math_exp : tty->print("java_lang_math_exp" ); break;
case java_lang_math_fmaD : tty->print("java_lang_math_fmaD" ); break;
case java_lang_math_fmaF : tty->print("java_lang_math_fmaF" ); break;
case java_lang_math_sqrt : tty->print("java_lang_math_sqrt" ); break;
case java_lang_math_sqrt_strict : tty->print("java_lang_math_sqrt_strict"); break;
case java_util_zip_CRC32_update : tty->print("java_util_zip_CRC32_update"); break;
case java_util_zip_CRC32_updateBytes : tty->print("java_util_zip_CRC32_updateBytes"); break;
case java_util_zip_CRC32_updateByteBuffer : tty->print("java_util_zip_CRC32_updateByteBuffer"); break;
case java_util_zip_CRC32C_updateBytes : tty->print("java_util_zip_CRC32C_updateBytes"); break;
case java_util_zip_CRC32C_updateDirectByteBuffer: tty->print("java_util_zip_CRC32C_updateDirectByteByffer"); break;
case java_lang_ref_reference_get : tty->print("java_lang_ref_reference_get"); break;
case java_lang_Thread_currentThread : tty->print("java_lang_Thread_currentThread"); break;
case java_lang_Float_intBitsToFloat : tty->print("java_lang_Float_intBitsToFloat"); break;
case java_lang_Float_floatToRawIntBits : tty->print("java_lang_Float_floatToRawIntBits"); break;
case java_lang_Double_longBitsToDouble : tty->print("java_lang_Double_longBitsToDouble"); break;
case java_lang_Double_doubleToRawLongBits : tty->print("java_lang_Double_doubleToRawLongBits"); break;
case java_lang_Float_float16ToFloat : tty->print("java_lang_Float_float16ToFloat"); break;
case java_lang_Float_floatToFloat16 : tty->print("java_lang_Float_floatToFloat16"); break;
default:
if (kind >= method_handle_invoke_FIRST &&
kind <= method_handle_invoke_LAST) {

8
src/hotspot/share/interpreter/abstractInterpreter.hpp
View file

@ -74,6 +74,7 @@ class AbstractInterpreter: AllStatic {
java_lang_math_tan, // implementation of java.lang.Math.tan (x)
java_lang_math_abs, // implementation of java.lang.Math.abs (x)
java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x)
java_lang_math_sqrt_strict, // implementation of java.lang.StrictMath.sqrt(x)
java_lang_math_log, // implementation of java.lang.Math.log (x)
java_lang_math_log10, // implementation of java.lang.Math.log10 (x)
java_lang_math_pow, // implementation of java.lang.Math.pow (x,y)
@ -105,6 +106,9 @@ class AbstractInterpreter: AllStatic {
return vmIntrinsics::_none;
}
// Conversion from the above enum to vmIntrinsics::ID
static vmIntrinsics::ID method_intrinsic(MethodKind kind);
enum SomeConstants {
number_of_result_handlers = 10 // number of result handlers for native calls
};
@ -114,9 +118,6 @@ class AbstractInterpreter: AllStatic {
static bool _notice_safepoints; // true if safepoints are activated
static address _native_entry_begin; // Region for native entry code
static address _native_entry_end;
// method entry points
static address _entry_table[number_of_method_entries]; // entry points for a given method
static address _native_abi_to_tosca[number_of_result_handlers]; // for native method result handlers
@ -223,7 +224,6 @@ class AbstractInterpreter: AllStatic {
static address slow_signature_handler() { return _slow_signature_handler; }
static address result_handler(BasicType type) { return _native_abi_to_tosca[BasicType_as_index(type)]; }
static int BasicType_as_index(BasicType type); // computes index into result_handler_by_index table
static bool in_native_entry(address pc) { return _native_entry_begin <= pc && pc < _native_entry_end; }
// Debugging/printing
static void print(); // prints the interpreter code

164
src/hotspot/share/interpreter/templateInterpreterGenerator.cpp
View file

@ -179,7 +179,7 @@ void TemplateInterpreterGenerator::generate_all() {
#define method_entry(kind) \
{ CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \
Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind, false); \
}
// all non-native method kinds
@ -194,6 +194,7 @@ void TemplateInterpreterGenerator::generate_all() {
method_entry(java_lang_math_tan )
method_entry(java_lang_math_abs )
method_entry(java_lang_math_sqrt )
method_entry(java_lang_math_sqrt_strict)
method_entry(java_lang_math_log )
method_entry(java_lang_math_log10)
method_entry(java_lang_math_exp )
@ -201,33 +202,41 @@ void TemplateInterpreterGenerator::generate_all() {
method_entry(java_lang_math_fmaF )
method_entry(java_lang_math_fmaD )
method_entry(java_lang_ref_reference_get)
#if defined(AMD64) || defined(AARCH64) || defined(RISCV64)
method_entry(java_lang_Thread_currentThread)
#endif
AbstractInterpreter::initialize_method_handle_entries();
// all native method kinds (must be one contiguous block)
Interpreter::_native_entry_begin = Interpreter::code()->code_end();
method_entry(native)
method_entry(native_synchronized)
Interpreter::_native_entry_end = Interpreter::code()->code_end();
method_entry(java_util_zip_CRC32_update)
method_entry(java_util_zip_CRC32_updateBytes)
method_entry(java_util_zip_CRC32_updateByteBuffer)
method_entry(java_util_zip_CRC32C_updateBytes)
method_entry(java_util_zip_CRC32C_updateDirectByteBuffer)
method_entry(java_lang_Float_intBitsToFloat);
method_entry(java_lang_Float_floatToRawIntBits);
method_entry(java_lang_Double_longBitsToDouble);
method_entry(java_lang_Double_doubleToRawLongBits);
method_entry(java_lang_Float_float16ToFloat);
method_entry(java_lang_Float_floatToFloat16);
#undef method_entry
// all native method kinds
#define native_method_entry(kind) \
{ CodeletMark cm(_masm, "native method entry point (kind = " #kind ")"); \
Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind, true); \
}
native_method_entry(native)
native_method_entry(native_synchronized)
// Entries to intrinsics for native methods should follow
// entries for `native` methods to use the same address in case
// intrinsic is disabled.
native_method_entry(java_lang_Thread_currentThread)
native_method_entry(java_util_zip_CRC32_update)
native_method_entry(java_util_zip_CRC32_updateBytes)
native_method_entry(java_util_zip_CRC32_updateByteBuffer)
native_method_entry(java_lang_Float_intBitsToFloat)
native_method_entry(java_lang_Float_floatToRawIntBits)
native_method_entry(java_lang_Double_longBitsToDouble)
native_method_entry(java_lang_Double_doubleToRawLongBits)
#undef native_method_entry
// Bytecodes
set_entry_points_for_all_bytes();
@ -397,74 +406,22 @@ void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState t
// Generate method entries
address TemplateInterpreterGenerator::generate_method_entry(
AbstractInterpreter::MethodKind kind) {
AbstractInterpreter::MethodKind kind, bool native) {
// determine code generation flags
bool native = false;
bool synchronized = false;
address entry_point = nullptr;
switch (kind) {
case Interpreter::zerolocals : break;
case Interpreter::zerolocals_synchronized: synchronized = true; break;
case Interpreter::native : native = true; break;
case Interpreter::native_synchronized : native = true; synchronized = true; break;
case Interpreter::native : break;
case Interpreter::native_synchronized : synchronized = true; break;
case Interpreter::empty : break;
case Interpreter::getter : break;
case Interpreter::setter : break;
case Interpreter::abstract : entry_point = generate_abstract_entry(); break;
case Interpreter::java_lang_math_sin : // fall thru
case Interpreter::java_lang_math_cos : // fall thru
case Interpreter::java_lang_math_tan : // fall thru
case Interpreter::java_lang_math_abs : // fall thru
case Interpreter::java_lang_math_log : // fall thru
case Interpreter::java_lang_math_log10 : // fall thru
case Interpreter::java_lang_math_sqrt : // fall thru
case Interpreter::java_lang_math_pow : // fall thru
case Interpreter::java_lang_math_exp : // fall thru
case Interpreter::java_lang_math_fmaD : // fall thru
case Interpreter::java_lang_math_fmaF : entry_point = generate_math_entry(kind); break;
case Interpreter::java_lang_ref_reference_get
: entry_point = generate_Reference_get_entry(); break;
case Interpreter::java_util_zip_CRC32_update
: native = true; entry_point = generate_CRC32_update_entry(); break;
case Interpreter::java_util_zip_CRC32_updateBytes
: // fall thru
case Interpreter::java_util_zip_CRC32_updateByteBuffer
: native = true; entry_point = generate_CRC32_updateBytes_entry(kind); break;
case Interpreter::java_util_zip_CRC32C_updateBytes
: // fall thru
case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer
: entry_point = generate_CRC32C_updateBytes_entry(kind); break;
#if defined(AMD64) || defined(AARCH64) || defined(RISCV64)
case Interpreter::java_lang_Thread_currentThread
: entry_point = generate_currentThread(); break;
#endif
case Interpreter::java_lang_Float_float16ToFloat
: entry_point = generate_Float_float16ToFloat_entry(); break;
case Interpreter::java_lang_Float_floatToFloat16
: entry_point = generate_Float_floatToFloat16_entry(); break;
#ifdef IA32
// On x86_32 platforms, a special entry is generated for the following four methods.
// On other platforms the normal entry is used to enter these methods.
case Interpreter::java_lang_Float_intBitsToFloat
: native = true; entry_point = generate_Float_intBitsToFloat_entry(); break;
case Interpreter::java_lang_Float_floatToRawIntBits
: native = true; entry_point = generate_Float_floatToRawIntBits_entry(); break;
case Interpreter::java_lang_Double_longBitsToDouble
: native = true; entry_point = generate_Double_longBitsToDouble_entry(); break;
case Interpreter::java_lang_Double_doubleToRawLongBits
: native = true; entry_point = generate_Double_doubleToRawLongBits_entry(); break;
#else
case Interpreter::java_lang_Float_intBitsToFloat:
case Interpreter::java_lang_Float_floatToRawIntBits:
case Interpreter::java_lang_Double_longBitsToDouble:
case Interpreter::java_lang_Double_doubleToRawLongBits:
native = true;
break;
#endif // !IA32
default:
fatal("unexpected method kind: %d", kind);
entry_point = generate_intrinsic_entry(kind); // process the rest
break;
}
@ -487,3 +444,62 @@ address TemplateInterpreterGenerator::generate_method_entry(
return entry_point;
}
// Generate intrinsic method entries
address TemplateInterpreterGenerator::generate_intrinsic_entry(AbstractInterpreter::MethodKind kind) {
if (!InlineIntrinsics || !vmIntrinsics::is_intrinsic_available(AbstractInterpreter::method_intrinsic(kind))) {
return nullptr;
}
address entry_point = nullptr;
switch (kind) {
case Interpreter::java_lang_math_sin : // fall thru
case Interpreter::java_lang_math_cos : // fall thru
case Interpreter::java_lang_math_tan : // fall thru
case Interpreter::java_lang_math_abs : // fall thru
case Interpreter::java_lang_math_log : // fall thru
case Interpreter::java_lang_math_log10 : // fall thru
case Interpreter::java_lang_math_sqrt : // fall thru
case Interpreter::java_lang_math_pow : // fall thru
case Interpreter::java_lang_math_exp : // fall thru
case Interpreter::java_lang_math_fmaD : // fall thru
case Interpreter::java_lang_math_fmaF : entry_point = generate_math_entry(kind); break;
case Interpreter::java_lang_math_sqrt_strict
: entry_point = generate_math_entry(Interpreter::java_lang_math_sqrt); break;
case Interpreter::java_lang_ref_reference_get
: entry_point = generate_Reference_get_entry(); break;
case Interpreter::java_util_zip_CRC32_update
: entry_point = generate_CRC32_update_entry(); break;
case Interpreter::java_util_zip_CRC32_updateBytes
: // fall thru
case Interpreter::java_util_zip_CRC32_updateByteBuffer
: entry_point = generate_CRC32_updateBytes_entry(kind); break;
case Interpreter::java_util_zip_CRC32C_updateBytes
: // fall thru
case Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer
: entry_point = generate_CRC32C_updateBytes_entry(kind); break;
case Interpreter::java_lang_Thread_currentThread
: entry_point = generate_currentThread(); break;
case Interpreter::java_lang_Float_float16ToFloat
: entry_point = generate_Float_float16ToFloat_entry(); break;
case Interpreter::java_lang_Float_floatToFloat16
: entry_point = generate_Float_floatToFloat16_entry(); break;
// On x86_32 platforms, a special entry is generated for the following four methods.
// On other platforms the native entry is used to enter these methods.
case Interpreter::java_lang_Float_intBitsToFloat
: entry_point = generate_Float_intBitsToFloat_entry(); break;
case Interpreter::java_lang_Float_floatToRawIntBits
: entry_point = generate_Float_floatToRawIntBits_entry(); break;
case Interpreter::java_lang_Double_longBitsToDouble
: entry_point = generate_Double_longBitsToDouble_entry(); break;
case Interpreter::java_lang_Double_doubleToRawLongBits
: entry_point = generate_Double_doubleToRawLongBits_entry(); break;
default:
fatal("unexpected intrinsic method kind: %d", kind);
break;
}
return entry_point;
}

9
src/hotspot/share/interpreter/templateInterpreterGenerator.hpp
View file

@ -84,7 +84,10 @@ class TemplateInterpreterGenerator: public AbstractInterpreterGenerator {
void generate_all();
// entry point generator
address generate_method_entry(AbstractInterpreter::MethodKind kind);
address generate_method_entry(AbstractInterpreter::MethodKind kind, bool native);
// generate intrinsic method entries
address generate_intrinsic_entry(AbstractInterpreter::MethodKind kind);
address generate_normal_entry(bool synchronized);
address generate_native_entry(bool synchronized);
@ -94,15 +97,11 @@ class TemplateInterpreterGenerator: public AbstractInterpreterGenerator {
address generate_CRC32_update_entry();
address generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind);
address generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind);
#if defined(AMD64) || defined(AARCH64) || defined(RISCV64)
address generate_currentThread();
#endif
#ifdef IA32
address generate_Float_intBitsToFloat_entry();
address generate_Float_floatToRawIntBits_entry();
address generate_Double_longBitsToDouble_entry();
address generate_Double_doubleToRawLongBits_entry();
#endif // IA32
address generate_Float_float16ToFloat_entry();
address generate_Float_floatToFloat16_entry();

2
src/hotspot/share/interpreter/zero/zeroInterpreterGenerator.cpp
View file

@ -66,10 +66,8 @@ void ZeroInterpreterGenerator::generate_all() {
AbstractInterpreter::initialize_method_handle_entries();
Interpreter::_native_entry_begin = Interpreter::code()->code_end();
method_entry(native);
method_entry(native_synchronized);
Interpreter::_native_entry_end = Interpreter::code()->code_end();
}
#undef method_entry

16
src/hotspot/share/opto/c2compiler.cpp
View file

@ -180,7 +180,7 @@ void C2Compiler::print_timers() {
Compile::print_timers();
}
bool C2Compiler::is_intrinsic_supported(const methodHandle& method, bool is_virtual) {
bool C2Compiler::is_intrinsic_supported(const methodHandle& method) {
vmIntrinsics::ID id = method->intrinsic_id();
assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
@ -188,20 +188,6 @@ bool C2Compiler::is_intrinsic_supported(const methodHandle& method, bool is_virt
return false;
}
// Only Object.hashCode and Object.clone intrinsics implement also a virtual
// dispatch because calling both methods is expensive but both methods are
// frequently overridden. All other intrinsics implement only a non-virtual
// dispatch.
if (is_virtual) {
switch (id) {
case vmIntrinsics::_hashCode:
case vmIntrinsics::_clone:
break;
default:
return false;
}
}
switch (id) {
case vmIntrinsics::_compressStringC:
case vmIntrinsics::_compressStringB:

8
src/hotspot/share/opto/c2compiler.hpp
View file

@ -61,13 +61,7 @@ public:
// possible for only a limited set of available intrinsics whereas
// a non-virtual dispatch is possible for all available intrinsics.)
// Return false otherwise.
virtual bool is_intrinsic_supported(const methodHandle& method) {
return is_intrinsic_supported(method, false);
}
// Check if the compiler supports an intrinsic for 'method' given the
// the dispatch mode specified by the 'is_virtual' parameter.
bool is_intrinsic_supported(const methodHandle& method, bool is_virtual);
virtual bool is_intrinsic_supported(const methodHandle& method);
// Initial size of the code buffer (may be increased at runtime)
static int initial_code_buffer_size(int const_size = initial_const_capacity);

8
src/hotspot/share/opto/library_call.cpp
View file

@ -77,10 +77,10 @@ CallGenerator* Compile::make_vm_intrinsic(ciMethod* m, bool is_virtual) {
// methods access VM-internal data.
VM_ENTRY_MARK;
methodHandle mh(THREAD, m->get_Method());
is_available = compiler != nullptr && compiler->is_intrinsic_supported(mh, is_virtual) &&
!C->directive()->is_intrinsic_disabled(mh) &&
!vmIntrinsics::is_disabled_by_flags(mh);
is_available = compiler != nullptr && compiler->is_intrinsic_available(mh, C->directive());
if (is_available && is_virtual) {
is_available = vmIntrinsics::does_virtual_dispatch(id);
}
}
if (is_available) {

5
src/hotspot/share/runtime/abstract_vm_version.hpp
View file

@ -42,6 +42,7 @@ typedef enum {
} VirtualizationType;
class outputStream;
enum class vmIntrinsicID;
// Abstract_VM_Version provides information about the VM.
@ -181,6 +182,10 @@ class Abstract_VM_Version: AllStatic {
// Does platform support float16 instructions?
static bool supports_float16() { return false; }
// Does this CPU support this intrinsic?
static bool is_intrinsic_supported(vmIntrinsicID id) { return true; }
static bool print_matching_lines_from_file(const char* filename, outputStream* st, const char* keywords_to_match[]);
protected:

2
src/hotspot/share/runtime/globals.hpp
View file

@ -1194,7 +1194,7 @@ const int ObjectAlignmentInBytes = 8;
"Trace frequency based inlining") \
\
develop_pd(bool, InlineIntrinsics, \
"Inline intrinsics that can be statically resolved") \
"Use intrinsics in Interpreter that can be statically resolved") \
\
product_pd(bool, ProfileInterpreter, \
"Profile at the bytecode level during interpretation") \

5
test/hotspot/jtreg/compiler/floatingpoint/NaNTest.java
View file

@ -83,8 +83,9 @@ public class NaNTest {
// signaling NaNs.
if (Platform.isX86()) {
int sse = WHITE_BOX.getIntVMFlag("UseSSE").intValue();
expectStableFloats = (sse >= 1);
expectStableDoubles = (sse >= 2);
boolean stubsPresent = WHITE_BOX.getBooleanVMFlag("InlineIntrinsics");
expectStableFloats = (sse >= 1) && stubsPresent;
expectStableDoubles = (sse >= 2) && stubsPresent;
}
if (expectStableFloats) {