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

annotate src/share/vm/runtime/stubRoutines.hpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	a3ecd773a7b9
children	f2110083203d d2907f74462e

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2 * Copyright (c) 1997, 2012, 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;
0 a61af66fc99e Initial load duke parents: diff changeset	131 static address _throw_NullPointerException_at_call_entry;
a61af66fc99e Initial load duke parents: diff changeset	132 static address _throw_StackOverflowError_entry;
a61af66fc99e Initial load duke parents: diff changeset	133 static address _handler_for_unsafe_access_entry;
a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 static address _atomic_xchg_entry;
a61af66fc99e Initial load duke parents: diff changeset	136 static address _atomic_xchg_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	137 static address _atomic_store_entry;
a61af66fc99e Initial load duke parents: diff changeset	138 static address _atomic_store_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	139 static address _atomic_cmpxchg_entry;
a61af66fc99e Initial load duke parents: diff changeset	140 static address _atomic_cmpxchg_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	141 static address _atomic_cmpxchg_long_entry;
a61af66fc99e Initial load duke parents: diff changeset	142 static address _atomic_add_entry;
a61af66fc99e Initial load duke parents: diff changeset	143 static address _atomic_add_ptr_entry;
a61af66fc99e Initial load duke parents: diff changeset	144 static address _fence_entry;
a61af66fc99e Initial load duke parents: diff changeset	145 static address _d2i_wrapper;
a61af66fc99e Initial load duke parents: diff changeset	146 static address _d2l_wrapper;
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 static jint _fpu_cntrl_wrd_std;
a61af66fc99e Initial load duke parents: diff changeset	149 static jint _fpu_cntrl_wrd_24;
a61af66fc99e Initial load duke parents: diff changeset	150 static jint _fpu_cntrl_wrd_64;
a61af66fc99e Initial load duke parents: diff changeset	151 static jint _fpu_cntrl_wrd_trunc;
a61af66fc99e Initial load duke parents: diff changeset	152 static jint _mxcsr_std;
a61af66fc99e Initial load duke parents: diff changeset	153 static jint _fpu_subnormal_bias1[3];
a61af66fc99e Initial load duke parents: diff changeset	154 static jint _fpu_subnormal_bias2[3];
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 static BufferBlob* _code1; // code buffer for initial routines
a61af66fc99e Initial load duke parents: diff changeset	157 static BufferBlob* _code2; // code buffer for all other routines
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // Leaf routines which implement arraycopy and their addresses
a61af66fc99e Initial load duke parents: diff changeset	160 // arraycopy operands aligned on element type boundary
a61af66fc99e Initial load duke parents: diff changeset	161 static address _jbyte_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	162 static address _jshort_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	163 static address _jint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	164 static address _jlong_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	165 static address _oop_arraycopy, _oop_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	166 static address _jbyte_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	167 static address _jshort_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	168 static address _jint_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	169 static address _jlong_disjoint_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	170 static address _oop_disjoint_arraycopy, _oop_disjoint_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 // arraycopy operands aligned on zero'th element boundary
a61af66fc99e Initial load duke parents: diff changeset	173 // These are identical to the ones aligned aligned on an
a61af66fc99e Initial load duke parents: diff changeset	174 // element type boundary, except that they assume that both
a61af66fc99e Initial load duke parents: diff changeset	175 // source and destination are HeapWord aligned.
a61af66fc99e Initial load duke parents: diff changeset	176 static address _arrayof_jbyte_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	177 static address _arrayof_jshort_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	178 static address _arrayof_jint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	179 static address _arrayof_jlong_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	180 static address _arrayof_oop_arraycopy, _arrayof_oop_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	181 static address _arrayof_jbyte_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	182 static address _arrayof_jshort_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	183 static address _arrayof_jint_disjoint_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	184 static address _arrayof_jlong_disjoint_arraycopy;
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	185 static address _arrayof_oop_disjoint_arraycopy, _arrayof_oop_disjoint_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	186
a61af66fc99e Initial load duke parents: diff changeset	187 // these are recommended but optional:
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	188 static address _checkcast_arraycopy, _checkcast_arraycopy_uninit;
0 a61af66fc99e Initial load duke parents: diff changeset	189 static address _unsafe_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	190 static address _generic_arraycopy;
a61af66fc99e Initial load duke parents: diff changeset	191
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	192 static address _jbyte_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	193 static address _jshort_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	194 static address _jint_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	195 static address _arrayof_jbyte_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	196 static address _arrayof_jshort_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	197 static address _arrayof_jint_fill;
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	198
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	199 // zero heap space aligned to jlong (8 bytes)
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	200 static address _zero_aligned_words;
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	201
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	202 static address _aescrypt_encryptBlock;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	203 static address _aescrypt_decryptBlock;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	204 static address _cipherBlockChaining_encryptAESCrypt;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	205 static address _cipherBlockChaining_decryptAESCrypt;
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	206
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	207 // 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	208 // 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	209 // 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	210 // 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	211 // 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	212 // SharedRuntime.
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	213 static double (*_intrinsic_log)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	214 static double (*_intrinsic_log10)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	215 static double (*_intrinsic_exp)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	216 static double (*_intrinsic_pow)(double, double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	217 static double (*_intrinsic_sin)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	218 static double (*_intrinsic_cos)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	219 static double (*_intrinsic_tan)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	220
0 a61af66fc99e Initial load duke parents: diff changeset	221 public:
a61af66fc99e Initial load duke parents: diff changeset	222 // Initialization/Testing
a61af66fc99e Initial load duke parents: diff changeset	223 static void initialize1(); // must happen before universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	224 static void initialize2(); // must happen after universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 static bool contains(address addr) {
a61af66fc99e Initial load duke parents: diff changeset	227 return
a61af66fc99e Initial load duke parents: diff changeset	228 (_code1 != NULL && _code1->blob_contains(addr)) \|\|
a61af66fc99e Initial load duke parents: diff changeset	229 (_code2 != NULL && _code2->blob_contains(addr)) ;
a61af66fc99e Initial load duke parents: diff changeset	230 }
a61af66fc99e Initial load duke parents: diff changeset	231
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	232 static CodeBlob* code1() { return _code1; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	233 static CodeBlob* code2() { return _code2; }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 3937 diff changeset	234
0 a61af66fc99e Initial load duke parents: diff changeset	235 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	236 static jint verify_oop_count() { return _verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	237 static jint* verify_oop_count_addr() { return &_verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	238 // a subroutine for debugging the GC
a61af66fc99e Initial load duke parents: diff changeset	239 static address verify_oop_subroutine_entry_address() { return (address)&_verify_oop_subroutine_entry; }
a61af66fc99e Initial load duke parents: diff changeset	240
a61af66fc99e Initial load duke parents: diff changeset	241 static address catch_exception_entry() { return _catch_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 // Calls to Java
a61af66fc99e Initial load duke parents: diff changeset	244 typedef void (*CallStub)(
a61af66fc99e Initial load duke parents: diff changeset	245 address link,
a61af66fc99e Initial load duke parents: diff changeset	246 intptr_t* result,
a61af66fc99e Initial load duke parents: diff changeset	247 BasicType result_type,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	248 Method* method,
0 a61af66fc99e Initial load duke parents: diff changeset	249 address entry_point,
a61af66fc99e Initial load duke parents: diff changeset	250 intptr_t* parameters,
a61af66fc99e Initial load duke parents: diff changeset	251 int size_of_parameters,
a61af66fc99e Initial load duke parents: diff changeset	252 TRAPS
a61af66fc99e Initial load duke parents: diff changeset	253 );
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 static CallStub call_stub() { return CAST_TO_FN_PTR(CallStub, _call_stub_entry); }
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 // Exceptions
a61af66fc99e Initial load duke parents: diff changeset	258 static address forward_exception_entry() { return _forward_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	259 // Implicit exceptions
a61af66fc99e Initial load duke parents: diff changeset	260 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	261 static address throw_IncompatibleClassChangeError_entry(){ return _throw_IncompatibleClassChangeError_entry; }
0 a61af66fc99e Initial load duke parents: diff changeset	262 static address throw_NullPointerException_at_call_entry(){ return _throw_NullPointerException_at_call_entry; }
a61af66fc99e Initial load duke parents: diff changeset	263 static address throw_StackOverflowError_entry() { return _throw_StackOverflowError_entry; }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 // Exceptions during unsafe access - should throw Java exception rather
a61af66fc99e Initial load duke parents: diff changeset	266 // than crash.
a61af66fc99e Initial load duke parents: diff changeset	267 static address handler_for_unsafe_access() { return _handler_for_unsafe_access_entry; }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 static address atomic_xchg_entry() { return _atomic_xchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	270 static address atomic_xchg_ptr_entry() { return _atomic_xchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	271 static address atomic_store_entry() { return _atomic_store_entry; }
a61af66fc99e Initial load duke parents: diff changeset	272 static address atomic_store_ptr_entry() { return _atomic_store_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	273 static address atomic_cmpxchg_entry() { return _atomic_cmpxchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	274 static address atomic_cmpxchg_ptr_entry() { return _atomic_cmpxchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	275 static address atomic_cmpxchg_long_entry() { return _atomic_cmpxchg_long_entry; }
a61af66fc99e Initial load duke parents: diff changeset	276 static address atomic_add_entry() { return _atomic_add_entry; }
a61af66fc99e Initial load duke parents: diff changeset	277 static address atomic_add_ptr_entry() { return _atomic_add_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	278 static address fence_entry() { return _fence_entry; }
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 static address d2i_wrapper() { return _d2i_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	281 static address d2l_wrapper() { return _d2l_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	282 static jint fpu_cntrl_wrd_std() { return _fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	283 static address addr_fpu_cntrl_wrd_std() { return (address)&_fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	284 static address addr_fpu_cntrl_wrd_24() { return (address)&_fpu_cntrl_wrd_24; }
a61af66fc99e Initial load duke parents: diff changeset	285 static address addr_fpu_cntrl_wrd_64() { return (address)&_fpu_cntrl_wrd_64; }
a61af66fc99e Initial load duke parents: diff changeset	286 static address addr_fpu_cntrl_wrd_trunc() { return (address)&_fpu_cntrl_wrd_trunc; }
a61af66fc99e Initial load duke parents: diff changeset	287 static address addr_mxcsr_std() { return (address)&_mxcsr_std; }
a61af66fc99e Initial load duke parents: diff changeset	288 static address addr_fpu_subnormal_bias1() { return (address)&_fpu_subnormal_bias1; }
a61af66fc99e Initial load duke parents: diff changeset	289 static address addr_fpu_subnormal_bias2() { return (address)&_fpu_subnormal_bias2; }
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291
2446 13bc79b5c9c8 7033154: Improve C1 arraycopy performance roland parents: 2324 diff changeset	292 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	293
0 a61af66fc99e Initial load duke parents: diff changeset	294 static address jbyte_arraycopy() { return _jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	295 static address jshort_arraycopy() { return _jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	296 static address jint_arraycopy() { return _jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	297 static address jlong_arraycopy() { return _jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	298 static address oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	299 return dest_uninitialized ? _oop_arraycopy_uninit : _oop_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	300 }
0 a61af66fc99e Initial load duke parents: diff changeset	301 static address jbyte_disjoint_arraycopy() { return _jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	302 static address jshort_disjoint_arraycopy() { return _jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	303 static address jint_disjoint_arraycopy() { return _jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	304 static address jlong_disjoint_arraycopy() { return _jlong_disjoint_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	305 static address oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	306 return dest_uninitialized ? _oop_disjoint_arraycopy_uninit : _oop_disjoint_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	307 }
0 a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 static address arrayof_jbyte_arraycopy() { return _arrayof_jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	310 static address arrayof_jshort_arraycopy() { return _arrayof_jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	311 static address arrayof_jint_arraycopy() { return _arrayof_jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	312 static address arrayof_jlong_arraycopy() { return _arrayof_jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	313 static address arrayof_oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	314 return dest_uninitialized ? _arrayof_oop_arraycopy_uninit : _arrayof_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
a61af66fc99e Initial load duke parents: diff changeset	317 static address arrayof_jbyte_disjoint_arraycopy() { return _arrayof_jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	318 static address arrayof_jshort_disjoint_arraycopy() { return _arrayof_jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	319 static address arrayof_jint_disjoint_arraycopy() { return _arrayof_jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	320 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	321 static address arrayof_oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	322 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	323 }
0 a61af66fc99e Initial load duke parents: diff changeset	324
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	325 static address checkcast_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	326 return dest_uninitialized ? _checkcast_arraycopy_uninit : _checkcast_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	327 }
0 a61af66fc99e Initial load duke parents: diff changeset	328 static address unsafe_arraycopy() { return _unsafe_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	329 static address generic_arraycopy() { return _generic_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	330
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	331 static address jbyte_fill() { return _jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	332 static address jshort_fill() { return _jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	333 static address jint_fill() { return _jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	334 static address arrayof_jbyte_fill() { return _arrayof_jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	335 static address arrayof_jshort_fill() { return _arrayof_jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	336 static address arrayof_jint_fill() { return _arrayof_jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	337
6894 a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	338 static address aescrypt_encryptBlock() { return _aescrypt_encryptBlock; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	339 static address aescrypt_decryptBlock() { return _aescrypt_decryptBlock; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	340 static address cipherBlockChaining_encryptAESCrypt() { return _cipherBlockChaining_encryptAESCrypt; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	341 static address cipherBlockChaining_decryptAESCrypt() { return _cipherBlockChaining_decryptAESCrypt; }
a3ecd773a7b9 7184394: add intrinsics to use AES instructions kvn parents: 6725 diff changeset	342
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	343 static address select_fill_function(BasicType t, bool aligned, const char* &name);
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	344
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	345 static address zero_aligned_words() { return _zero_aligned_words; }
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	346
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	347 static double intrinsic_log(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	348 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	349 return _intrinsic_log(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	350 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	351 static double intrinsic_log10(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	352 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	353 return _intrinsic_log10(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	354 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	355 static double intrinsic_exp(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	356 assert(_intrinsic_exp != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	357 return _intrinsic_exp(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	358 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	359 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	360 assert(_intrinsic_pow != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	361 return _intrinsic_pow(d, d2);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	362 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	363 static double intrinsic_sin(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	364 assert(_intrinsic_sin != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	365 return _intrinsic_sin(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	366 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	367 static double intrinsic_cos(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	368 assert(_intrinsic_cos != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	369 return _intrinsic_cos(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	370 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	371 static double intrinsic_tan(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	372 assert(_intrinsic_tan != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	373 return _intrinsic_tan(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	374 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	375
0 a61af66fc99e Initial load duke parents: diff changeset	376 //
a61af66fc99e Initial load duke parents: diff changeset	377 // Default versions of the above arraycopy functions for platforms which do
a61af66fc99e Initial load duke parents: diff changeset	378 // not have specialized versions
a61af66fc99e Initial load duke parents: diff changeset	379 //
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	380 static void jbyte_copy (jbyte* src, jbyte* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	381 static void jshort_copy (jshort* src, jshort* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	382 static void jint_copy (jint* src, jint* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	383 static void jlong_copy (jlong* src, jlong* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	384 static void oop_copy (oop* src, oop* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	385 static void oop_copy_uninit(oop* src, oop* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	386
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	387 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	388 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	389 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	390 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	391 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	392 static void arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	393 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	394
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	395 #endif // SHARE_VM_RUNTIME_STUBROUTINES_HPP

Mercurial > hg > truffle

annotate src/share/vm/runtime/stubRoutines.hpp @ 9126:bc26f978b0ce