truffle: src/share/vm/runtime/stubRoutines.hpp annotate

annotate src/share/vm/runtime/stubRoutines.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	6b0fd0964b87
children	d8041d695d19

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6894 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1174 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1174 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1174 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	25 #ifndef SHARE_VM_RUNTIME_STUBROUTINES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	26 #define SHARE_VM_RUNTIME_STUBROUTINES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	28 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	29 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	30 #include "runtime/frame.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	31 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	32 #include "runtime/stubCodeGenerator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	33 #include "utilities/top.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	34 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	35 # include "nativeInst_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	36 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	37 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	38 # include "nativeInst_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	39 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	40 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	41 # include "nativeInst_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	42 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	43 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	44 # include "nativeInst_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	45 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	46 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	47 # include "nativeInst_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	48 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	49
0 a61af66fc99e Initial load duke parents: diff changeset	50 // StubRoutines provides entry points to assembly routines used by
a61af66fc99e Initial load duke parents: diff changeset	51 // compiled code and the run-time system. Platform-specific entry
a61af66fc99e Initial load duke parents: diff changeset	52 // points are defined in the platform-specific inner class.
a61af66fc99e Initial load duke parents: diff changeset	53 //
a61af66fc99e Initial load duke parents: diff changeset	54 // Class scheme:
a61af66fc99e Initial load duke parents: diff changeset	55 //
a61af66fc99e Initial load duke parents: diff changeset	56 // platform-independent platform-dependent
a61af66fc99e Initial load duke parents: diff changeset	57 //
a61af66fc99e Initial load duke parents: diff changeset	58 // stubRoutines.hpp <-- included -- stubRoutines_<arch>.hpp
a61af66fc99e Initial load duke parents: diff changeset	59 // ^ ^
a61af66fc99e Initial load duke parents: diff changeset	60 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	61 // implements implements
a61af66fc99e Initial load duke parents: diff changeset	62 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	63 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	64 // stubRoutines.cpp stubRoutines_<arch>.cpp
a61af66fc99e Initial load duke parents: diff changeset	65 // stubRoutines_<os_family>.cpp stubGenerator_<arch>.cpp
a61af66fc99e Initial load duke parents: diff changeset	66 // stubRoutines_<os_arch>.cpp
a61af66fc99e Initial load duke parents: diff changeset	67 //
a61af66fc99e Initial load duke parents: diff changeset	68 // Note 1: The important thing is a clean decoupling between stub
a61af66fc99e Initial load duke parents: diff changeset	69 // entry points (interfacing to the whole vm; i.e., 1-to-n
a61af66fc99e Initial load duke parents: diff changeset	70 // relationship) and stub generators (interfacing only to
a61af66fc99e Initial load duke parents: diff changeset	71 // the entry points implementation; i.e., 1-to-1 relationship).
a61af66fc99e Initial load duke parents: diff changeset	72 // This significantly simplifies changes in the generator
a61af66fc99e Initial load duke parents: diff changeset	73 // structure since the rest of the vm is not affected.
a61af66fc99e Initial load duke parents: diff changeset	74 //
a61af66fc99e Initial load duke parents: diff changeset	75 // Note 2: stubGenerator_<arch>.cpp contains a minimal portion of
a61af66fc99e Initial load duke parents: diff changeset	76 // machine-independent code; namely the generator calls of
a61af66fc99e Initial load duke parents: diff changeset	77 // the generator functions that are used platform-independently.
a61af66fc99e Initial load duke parents: diff changeset	78 // However, it comes with the advantage of having a 1-file
a61af66fc99e Initial load duke parents: diff changeset	79 // implementation of the generator. It should be fairly easy
a61af66fc99e Initial load duke parents: diff changeset	80 // to change, should it become a problem later.
a61af66fc99e Initial load duke parents: diff changeset	81 //
a61af66fc99e Initial load duke parents: diff changeset	82 // Scheme for adding a new entry point:
a61af66fc99e Initial load duke parents: diff changeset	83 //
a61af66fc99e Initial load duke parents: diff changeset	84 // 1. determine if it's a platform-dependent or independent entry point
a61af66fc99e Initial load duke parents: diff changeset	85 // a) if platform independent: make subsequent changes in the independent files
a61af66fc99e Initial load duke parents: diff changeset	86 // b) if platform dependent: make subsequent changes in the dependent files
a61af66fc99e Initial load duke parents: diff changeset	87 // 2. add a private instance variable holding the entry point address
a61af66fc99e Initial load duke parents: diff changeset	88 // 3. add a public accessor function to the instance variable
a61af66fc99e Initial load duke parents: diff changeset	89 // 4. implement the corresponding generator function in the platform-dependent
a61af66fc99e Initial load duke parents: diff changeset	90 // stubGenerator_<arch>.cpp file and call the function in generate_all() of that file
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 class StubRoutines: AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 public:
a61af66fc99e Initial load duke parents: diff changeset	96 enum platform_independent_constants {
a61af66fc99e Initial load duke parents: diff changeset	97 max_size_of_parameters = 256 // max. parameter size supported by megamorphic lookups
a61af66fc99e Initial load duke parents: diff changeset	98 };
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 // Dependencies
a61af66fc99e Initial load duke parents: diff changeset	101 friend class StubGenerator;
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	102 #ifdef TARGET_ARCH_MODEL_x86_32
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	103 # include "stubRoutines_x86_32.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	104 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	105 #ifdef TARGET_ARCH_MODEL_x86_64
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	106 # include "stubRoutines_x86_64.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	107 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	108 #ifdef TARGET_ARCH_MODEL_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	109 # include "stubRoutines_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	110 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	111 #ifdef TARGET_ARCH_MODEL_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	112 # include "stubRoutines_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	113 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	114 #ifdef TARGET_ARCH_MODEL_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	115 # include "stubRoutines_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	116 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	117 #ifdef TARGET_ARCH_MODEL_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	118 # include "stubRoutines_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 1972 diff changeset	119 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	120
0 a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 static jint _verify_oop_count;
a61af66fc99e Initial load duke parents: diff changeset	123 static address _verify_oop_subroutine_entry;
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 static address _call_stub_return_address; // the return PC, when returning to a call stub
a61af66fc99e Initial load duke parents: diff changeset	126 static address _call_stub_entry;
a61af66fc99e Initial load duke parents: diff changeset	127 static address _forward_exception_entry;
a61af66fc99e Initial load duke parents: diff changeset	128 static address _catch_exception_entry;
a61af66fc99e Initial load duke parents: diff changeset	129 static address _throw_AbstractMethodError_entry;
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	130 static address _throw_IncompatibleClassChangeError_entry;
10479 40b8c383bc31 Throw InvalidInstalledCodeException directly in the stubs. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 10405 diff changeset	131 static address _throw_InvalidInstalledCodeException_entry;
0 a61af66fc99e Initial load duke parents: diff changeset	132 static address _throw_NullPointerException_at_call_entry;
a61af66fc99e Initial load duke parents: diff changeset	133 static address _throw_StackOverflowError_entry;
a61af66fc99e Initial load duke parents: diff changeset	134 static address _handler_for_unsafe_access_entry;
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 static address _atomic_xchg_entry;
a61af66fc99e Initial load duke parents: diff changeset	137 static address _atomic_xchg_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	138 static address _atomic_store_entry;
a61af66fc99e Initial load duke parents: diff changeset	139 static address _atomic_store_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	140 static address _atomic_cmpxchg_entry;
a61af66fc99e Initial load duke parents: diff changeset	141 static address _atomic_cmpxchg_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	142 static address _atomic_cmpxchg_long_entry;
a61af66fc99e Initial load duke parents: diff changeset	143 static address _atomic_add_entry;
a61af66fc99e Initial load duke parents: diff changeset	144 static address _atomic_add_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	145 static address _fence_entry;
a61af66fc99e Initial load duke parents: diff changeset	146 static address _d2i_wrapper;
a61af66fc99e Initial load duke parents: diff changeset	147 static address _d2l_wrapper;
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 static jint _fpu_cntrl_wrd_std;
a61af66fc99e Initial load duke parents: diff changeset	150 static jint _fpu_cntrl_wrd_24;
a61af66fc99e Initial load duke parents: diff changeset	151 static jint _fpu_cntrl_wrd_64;
a61af66fc99e Initial load duke parents: diff changeset	152 static jint _fpu_cntrl_wrd_trunc;
a61af66fc99e Initial load duke parents: diff changeset	153 static jint _mxcsr_std;
a61af66fc99e Initial load duke parents: diff changeset	154 static jint _fpu_subnormal_bias1[3];
a61af66fc99e Initial load duke parents: diff changeset	155 static jint _fpu_subnormal_bias2[3];
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 static BufferBlob* _code1; // code buffer for initial routines
a61af66fc99e Initial load duke parents: diff changeset	158 static BufferBlob* _code2; // code buffer for all other routines
a61af66fc99e Initial load duke parents: diff changeset	159
a61af66fc99e Initial load duke parents: diff changeset	160 // Leaf routines which implement arraycopy and their addresses
a61af66fc99e Initial load duke parents: diff changeset	161 // arraycopy operands aligned on element type boundary
a61af66fc99e Initial load duke parents: diff changeset	162 static address _jbyte_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	163 static address _jshort_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	164 static address _jint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	165 static address _jlong_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	166 static address _oop_arraycopy, _oop_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	167 static address _jbyte_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	168 static address _jshort_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	169 static address _jint_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	170 static address _jlong_disjoint_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	171 static address _oop_disjoint_arraycopy, _oop_disjoint_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	172
a61af66fc99e Initial load duke parents: diff changeset	173 // arraycopy operands aligned on zero'th element boundary
a61af66fc99e Initial load duke parents: diff changeset	174 // These are identical to the ones aligned aligned on an
a61af66fc99e Initial load duke parents: diff changeset	175 // element type boundary, except that they assume that both
a61af66fc99e Initial load duke parents: diff changeset	176 // source and destination are HeapWord aligned.
a61af66fc99e Initial load duke parents: diff changeset	177 static address _arrayof_jbyte_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	178 static address _arrayof_jshort_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	179 static address _arrayof_jint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	180 static address _arrayof_jlong_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	181 static address _arrayof_oop_arraycopy, _arrayof_oop_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	182 static address _arrayof_jbyte_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	183 static address _arrayof_jshort_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	184 static address _arrayof_jint_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	185 static address _arrayof_jlong_disjoint_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	186 static address _arrayof_oop_disjoint_arraycopy, _arrayof_oop_disjoint_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 // these are recommended but optional:
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	189 static address _checkcast_arraycopy, _checkcast_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	190 static address _unsafe_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	191 static address _generic_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	192
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	193 static address _jbyte_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	194 static address _jshort_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	195 static address _jint_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	196 static address _arrayof_jbyte_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	197 static address _arrayof_jshort_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	198 static address _arrayof_jint_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	199
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3451 diff changeset	200 // zero heap space aligned to jlong (8 bytes)
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3451 diff changeset	201 static address _zero_aligned_words;
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3451 diff changeset	202
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	203 static address _aescrypt_encryptBlock;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	204 static address _aescrypt_decryptBlock;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	205 static address _cipherBlockChaining_encryptAESCrypt;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	206 static address _cipherBlockChaining_decryptAESCrypt;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	207
11080 b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	208 static address _updateBytesCRC32;
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	209 static address _crc_table_adr;
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	210
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	211 // These are versions of the java.lang.Math methods which perform
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	212 // the same operations as the intrinsic version. They are used for
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	213 // constant folding in the compiler to ensure equivalence. If the
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	214 // intrinsic version returns the same result as the strict version
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	215 // then they can be set to the appropriate function from
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	216 // SharedRuntime.
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	217 static double (*_intrinsic_log)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	218 static double (*_intrinsic_log10)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	219 static double (*_intrinsic_exp)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	220 static double (*_intrinsic_pow)(double, double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	221 static double (*_intrinsic_sin)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	222 static double (*_intrinsic_cos)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	223 static double (*_intrinsic_tan)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	224
11127 980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	225 // Safefetch stubs.
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	226 static address _safefetch32_entry;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	227 static address _safefetch32_fault_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	228 static address _safefetch32_continuation_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	229 static address _safefetchN_entry;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	230 static address _safefetchN_fault_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	231 static address _safefetchN_continuation_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	232
0 a61af66fc99e Initial load duke parents: diff changeset	233 public:
a61af66fc99e Initial load duke parents: diff changeset	234 // Initialization/Testing
a61af66fc99e Initial load duke parents: diff changeset	235 static void initialize1(); // must happen before universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	236 static void initialize2(); // must happen after universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	237
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6894 diff changeset	238 static bool is_stub_code(address addr) { return contains(addr); }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 6894 diff changeset	239
0 a61af66fc99e Initial load duke parents: diff changeset	240 static bool contains(address addr) {
a61af66fc99e Initial load duke parents: diff changeset	241 return
a61af66fc99e Initial load duke parents: diff changeset	242 (_code1 != NULL && _code1->blob_contains(addr)) \|\|
a61af66fc99e Initial load duke parents: diff changeset	243 (_code2 != NULL && _code2->blob_contains(addr)) ;
a61af66fc99e Initial load duke parents: diff changeset	244 }
a61af66fc99e Initial load duke parents: diff changeset	245
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	246 static CodeBlob* code1() { return _code1; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	247 static CodeBlob* code2() { return _code2; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	248
0 a61af66fc99e Initial load duke parents: diff changeset	249 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	250 static jint verify_oop_count() { return _verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	251 static jint* verify_oop_count_addr() { return &_verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	252 // a subroutine for debugging the GC
a61af66fc99e Initial load duke parents: diff changeset	253 static address verify_oop_subroutine_entry_address() { return (address)&_verify_oop_subroutine_entry; }
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 static address catch_exception_entry() { return _catch_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 // Calls to Java
a61af66fc99e Initial load duke parents: diff changeset	258 typedef void (*CallStub)(
a61af66fc99e Initial load duke parents: diff changeset	259 address link,
a61af66fc99e Initial load duke parents: diff changeset	260 intptr_t* result,
a61af66fc99e Initial load duke parents: diff changeset	261 BasicType result_type,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	262 Method* method,
0 a61af66fc99e Initial load duke parents: diff changeset	263 address entry_point,
a61af66fc99e Initial load duke parents: diff changeset	264 intptr_t* parameters,
a61af66fc99e Initial load duke parents: diff changeset	265 int size_of_parameters,
a61af66fc99e Initial load duke parents: diff changeset	266 TRAPS
a61af66fc99e Initial load duke parents: diff changeset	267 );
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 static CallStub call_stub() { return CAST_TO_FN_PTR(CallStub, _call_stub_entry); }
a61af66fc99e Initial load duke parents: diff changeset	270
a61af66fc99e Initial load duke parents: diff changeset	271 // Exceptions
a61af66fc99e Initial load duke parents: diff changeset	272 static address forward_exception_entry() { return _forward_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	273 // Implicit exceptions
a61af66fc99e Initial load duke parents: diff changeset	274 static address throw_AbstractMethodError_entry() { return _throw_AbstractMethodError_entry; }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	275 static address throw_IncompatibleClassChangeError_entry(){ return _throw_IncompatibleClassChangeError_entry; }
10479 40b8c383bc31 Throw InvalidInstalledCodeException directly in the stubs. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 10405 diff changeset	276 static address throw_InvalidInstalledCodeException_entry(){ return _throw_InvalidInstalledCodeException_entry; }
0 a61af66fc99e Initial load duke parents: diff changeset	277 static address throw_NullPointerException_at_call_entry(){ return _throw_NullPointerException_at_call_entry; }
a61af66fc99e Initial load duke parents: diff changeset	278 static address throw_StackOverflowError_entry() { return _throw_StackOverflowError_entry; }
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // Exceptions during unsafe access - should throw Java exception rather
a61af66fc99e Initial load duke parents: diff changeset	281 // than crash.
a61af66fc99e Initial load duke parents: diff changeset	282 static address handler_for_unsafe_access() { return _handler_for_unsafe_access_entry; }
a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 static address atomic_xchg_entry() { return _atomic_xchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	285 static address atomic_xchg_ptr_entry() { return _atomic_xchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	286 static address atomic_store_entry() { return _atomic_store_entry; }
a61af66fc99e Initial load duke parents: diff changeset	287 static address atomic_store_ptr_entry() { return _atomic_store_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	288 static address atomic_cmpxchg_entry() { return _atomic_cmpxchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	289 static address atomic_cmpxchg_ptr_entry() { return _atomic_cmpxchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	290 static address atomic_cmpxchg_long_entry() { return _atomic_cmpxchg_long_entry; }
a61af66fc99e Initial load duke parents: diff changeset	291 static address atomic_add_entry() { return _atomic_add_entry; }
a61af66fc99e Initial load duke parents: diff changeset	292 static address atomic_add_ptr_entry() { return _atomic_add_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	293 static address fence_entry() { return _fence_entry; }
a61af66fc99e Initial load duke parents: diff changeset	294
a61af66fc99e Initial load duke parents: diff changeset	295 static address d2i_wrapper() { return _d2i_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	296 static address d2l_wrapper() { return _d2l_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	297 static jint fpu_cntrl_wrd_std() { return _fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	298 static address addr_fpu_cntrl_wrd_std() { return (address)&_fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	299 static address addr_fpu_cntrl_wrd_24() { return (address)&_fpu_cntrl_wrd_24; }
a61af66fc99e Initial load duke parents: diff changeset	300 static address addr_fpu_cntrl_wrd_64() { return (address)&_fpu_cntrl_wrd_64; }
a61af66fc99e Initial load duke parents: diff changeset	301 static address addr_fpu_cntrl_wrd_trunc() { return (address)&_fpu_cntrl_wrd_trunc; }
a61af66fc99e Initial load duke parents: diff changeset	302 static address addr_mxcsr_std() { return (address)&_mxcsr_std; }
a61af66fc99e Initial load duke parents: diff changeset	303 static address addr_fpu_subnormal_bias1() { return (address)&_fpu_subnormal_bias1; }
a61af66fc99e Initial load duke parents: diff changeset	304 static address addr_fpu_subnormal_bias2() { return (address)&_fpu_subnormal_bias2; }
a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306
2446 13bc79b5c9c8 7033154: Improve C1 arraycopy performance roland parents: 2324 diff changeset	307 static address select_arraycopy_function(BasicType t, bool aligned, bool disjoint, const char* &name, bool dest_uninitialized);
13bc79b5c9c8 7033154: Improve C1 arraycopy performance roland parents: 2324 diff changeset	308
0 a61af66fc99e Initial load duke parents: diff changeset	309 static address jbyte_arraycopy() { return _jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	310 static address jshort_arraycopy() { return _jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	311 static address jint_arraycopy() { return _jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	312 static address jlong_arraycopy() { return _jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	313 static address oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	314 return dest_uninitialized ? _oop_arraycopy_uninit : _oop_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	315 }
0 a61af66fc99e Initial load duke parents: diff changeset	316 static address jbyte_disjoint_arraycopy() { return _jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	317 static address jshort_disjoint_arraycopy() { return _jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	318 static address jint_disjoint_arraycopy() { return _jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	319 static address jlong_disjoint_arraycopy() { return _jlong_disjoint_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	320 static address oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	321 return dest_uninitialized ? _oop_disjoint_arraycopy_uninit : _oop_disjoint_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	322 }
0 a61af66fc99e Initial load duke parents: diff changeset	323
a61af66fc99e Initial load duke parents: diff changeset	324 static address arrayof_jbyte_arraycopy() { return _arrayof_jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	325 static address arrayof_jshort_arraycopy() { return _arrayof_jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	326 static address arrayof_jint_arraycopy() { return _arrayof_jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	327 static address arrayof_jlong_arraycopy() { return _arrayof_jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	328 static address arrayof_oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	329 return dest_uninitialized ? _arrayof_oop_arraycopy_uninit : _arrayof_oop_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	330 }
0 a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 static address arrayof_jbyte_disjoint_arraycopy() { return _arrayof_jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	333 static address arrayof_jshort_disjoint_arraycopy() { return _arrayof_jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	334 static address arrayof_jint_disjoint_arraycopy() { return _arrayof_jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	335 static address arrayof_jlong_disjoint_arraycopy() { return _arrayof_jlong_disjoint_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	336 static address arrayof_oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	337 return dest_uninitialized ? _arrayof_oop_disjoint_arraycopy_uninit : _arrayof_oop_disjoint_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	338 }
0 a61af66fc99e Initial load duke parents: diff changeset	339
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	340 static address checkcast_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	341 return dest_uninitialized ? _checkcast_arraycopy_uninit : _checkcast_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	342 }
0 a61af66fc99e Initial load duke parents: diff changeset	343 static address unsafe_arraycopy() { return _unsafe_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	344 static address generic_arraycopy() { return _generic_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	345
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	346 static address jbyte_fill() { return _jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	347 static address jshort_fill() { return _jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	348 static address jint_fill() { return _jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	349 static address arrayof_jbyte_fill() { return _arrayof_jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	350 static address arrayof_jshort_fill() { return _arrayof_jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	351 static address arrayof_jint_fill() { return _arrayof_jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	352
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	353 static address aescrypt_encryptBlock() { return _aescrypt_encryptBlock; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	354 static address aescrypt_decryptBlock() { return _aescrypt_decryptBlock; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	355 static address cipherBlockChaining_encryptAESCrypt() { return _cipherBlockChaining_encryptAESCrypt; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	356 static address cipherBlockChaining_decryptAESCrypt() { return _cipherBlockChaining_decryptAESCrypt; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	357
11080 b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	358 static address updateBytesCRC32() { return _updateBytesCRC32; }
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	359 static address crc_table_addr() { return _crc_table_adr; }
b800986664f4 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 drchase parents: 10405 diff changeset	360
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	361 static address select_fill_function(BasicType t, bool aligned, const char* &name);
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	362
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3451 diff changeset	363 static address zero_aligned_words() { return _zero_aligned_words; }
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	364
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	365 static double intrinsic_log(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	366 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	367 return _intrinsic_log(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	368 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	369 static double intrinsic_log10(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	370 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	371 return _intrinsic_log10(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	372 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	373 static double intrinsic_exp(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	374 assert(_intrinsic_exp != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	375 return _intrinsic_exp(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	376 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	377 static double intrinsic_pow(double d, double d2) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	378 assert(_intrinsic_pow != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	379 return _intrinsic_pow(d, d2);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	380 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	381 static double intrinsic_sin(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	382 assert(_intrinsic_sin != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	383 return _intrinsic_sin(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	384 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	385 static double intrinsic_cos(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	386 assert(_intrinsic_cos != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	387 return _intrinsic_cos(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	388 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	389 static double intrinsic_tan(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	390 assert(_intrinsic_tan != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	391 return _intrinsic_tan(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	392 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	393
0 a61af66fc99e Initial load duke parents: diff changeset	394 //
11127 980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	395 // Safefetch stub support
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	396 //
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	397
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	398 typedef int (SafeFetch32Stub)(int adr, int errValue);
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	399 typedef intptr_t (SafeFetchNStub) (intptr_t adr, intptr_t errValue);
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	400
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	401 static SafeFetch32Stub SafeFetch32_stub() { return CAST_TO_FN_PTR(SafeFetch32Stub, _safefetch32_entry); }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	402 static SafeFetchNStub SafeFetchN_stub() { return CAST_TO_FN_PTR(SafeFetchNStub, _safefetchN_entry); }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	403
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	404 static bool is_safefetch_fault(address pc) {
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	405 return pc != NULL &&
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	406 (pc == _safefetch32_fault_pc \|\|
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	407 pc == _safefetchN_fault_pc);
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	408 }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	409
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	410 static address continuation_for_safefetch_fault(address pc) {
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	411 assert(_safefetch32_continuation_pc != NULL &&
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	412 _safefetchN_continuation_pc != NULL,
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	413 "not initialized");
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	414
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	415 if (pc == _safefetch32_fault_pc) return _safefetch32_continuation_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	416 if (pc == _safefetchN_fault_pc) return _safefetchN_continuation_pc;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	417
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	418 ShouldNotReachHere();
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	419 return NULL;
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	420 }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	421
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	422 //
0 a61af66fc99e Initial load duke parents: diff changeset	423 // Default versions of the above arraycopy functions for platforms which do
a61af66fc99e Initial load duke parents: diff changeset	424 // not have specialized versions
a61af66fc99e Initial load duke parents: diff changeset	425 //
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	426 static void jbyte_copy (jbyte* src, jbyte* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	427 static void jshort_copy (jshort* src, jshort* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	428 static void jint_copy (jint* src, jint* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	429 static void jlong_copy (jlong* src, jlong* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	430 static void oop_copy (oop* src, oop* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	431 static void oop_copy_uninit(oop* src, oop* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	432
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	433 static void arrayof_jbyte_copy (HeapWord* src, HeapWord* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	434 static void arrayof_jshort_copy (HeapWord* src, HeapWord* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	435 static void arrayof_jint_copy (HeapWord* src, HeapWord* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	436 static void arrayof_jlong_copy (HeapWord* src, HeapWord* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	437 static void arrayof_oop_copy (HeapWord* src, HeapWord* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	438 static void arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	439 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	440
11127 980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	441 // Safefetch allows to load a value from a location that's not known
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	442 // to be valid. If the load causes a fault, the error value is returned.
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	443 inline int SafeFetch32(int* adr, int errValue) {
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	444 assert(StubRoutines::SafeFetch32_stub(), "stub not yet generated");
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	445 return StubRoutines::SafeFetch32_stub()(adr, errValue);
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	446 }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	447 inline intptr_t SafeFetchN(intptr_t* adr, intptr_t errValue) {
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	448 assert(StubRoutines::SafeFetchN_stub(), "stub not yet generated");
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	449 return StubRoutines::SafeFetchN_stub()(adr, errValue);
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	450 }
980532a806a5 8016697: Use stubs to implement safefetch goetz parents: 11080 diff changeset	451
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	452 #endif // SHARE_VM_RUNTIME_STUBROUTINES_HPP

Mercurial > hg > truffle

annotate src/share/vm/runtime/stubRoutines.hpp @ 13212:eb03a7335eb0