graal-jvmci-8: src/share/vm/runtime/stubRoutines.hpp annotate

annotate src/share/vm/runtime/stubRoutines.hpp @ 3979:4dfb2df418f2

6484982: G1: process references during evacuation pauses Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate. Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp

author	johnc
date	Thu, 22 Sep 2011 10:57:37 -0700
parents	c565834fb592
children	1d7922586cf6

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	2 * Copyright (c) 1997, 2011, 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;
3781 d83ac25d0304 7055355: JSR 292: crash while throwing WrongMethodTypeException never parents: 2446 diff changeset	133 static address _throw_WrongMethodTypeException_entry;
0 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: 3781 diff changeset	200 // zero heap space aligned to jlong (8 bytes)
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	201 static address _zero_aligned_words;
baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	202
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	203 // 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	204 // 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	205 // 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	206 // 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	207 // 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	208 // SharedRuntime.
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	209 static double (*_intrinsic_log)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	210 static double (*_intrinsic_log10)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	211 static double (*_intrinsic_exp)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	212 static double (*_intrinsic_pow)(double, double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	213 static double (*_intrinsic_sin)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	214 static double (*_intrinsic_cos)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	215 static double (*_intrinsic_tan)(double);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	216
0 a61af66fc99e Initial load duke parents: diff changeset	217 public:
a61af66fc99e Initial load duke parents: diff changeset	218 // Initialization/Testing
a61af66fc99e Initial load duke parents: diff changeset	219 static void initialize1(); // must happen before universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	220 static void initialize2(); // must happen after universe::genesis
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 static bool contains(address addr) {
a61af66fc99e Initial load duke parents: diff changeset	223 return
a61af66fc99e Initial load duke parents: diff changeset	224 (_code1 != NULL && _code1->blob_contains(addr)) \|\|
a61af66fc99e Initial load duke parents: diff changeset	225 (_code2 != NULL && _code2->blob_contains(addr)) ;
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	229 static jint verify_oop_count() { return _verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	230 static jint* verify_oop_count_addr() { return &_verify_oop_count; }
a61af66fc99e Initial load duke parents: diff changeset	231 // a subroutine for debugging the GC
a61af66fc99e Initial load duke parents: diff changeset	232 static address verify_oop_subroutine_entry_address() { return (address)&_verify_oop_subroutine_entry; }
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 static address catch_exception_entry() { return _catch_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 // Calls to Java
a61af66fc99e Initial load duke parents: diff changeset	237 typedef void (*CallStub)(
a61af66fc99e Initial load duke parents: diff changeset	238 address link,
a61af66fc99e Initial load duke parents: diff changeset	239 intptr_t* result,
a61af66fc99e Initial load duke parents: diff changeset	240 BasicType result_type,
a61af66fc99e Initial load duke parents: diff changeset	241 methodOopDesc* method,
a61af66fc99e Initial load duke parents: diff changeset	242 address entry_point,
a61af66fc99e Initial load duke parents: diff changeset	243 intptr_t* parameters,
a61af66fc99e Initial load duke parents: diff changeset	244 int size_of_parameters,
a61af66fc99e Initial load duke parents: diff changeset	245 TRAPS
a61af66fc99e Initial load duke parents: diff changeset	246 );
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 static CallStub call_stub() { return CAST_TO_FN_PTR(CallStub, _call_stub_entry); }
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250 // Exceptions
a61af66fc99e Initial load duke parents: diff changeset	251 static address forward_exception_entry() { return _forward_exception_entry; }
a61af66fc99e Initial load duke parents: diff changeset	252 // Implicit exceptions
a61af66fc99e Initial load duke parents: diff changeset	253 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	254 static address throw_IncompatibleClassChangeError_entry(){ return _throw_IncompatibleClassChangeError_entry; }
0 a61af66fc99e Initial load duke parents: diff changeset	255 static address throw_NullPointerException_at_call_entry(){ return _throw_NullPointerException_at_call_entry; }
a61af66fc99e Initial load duke parents: diff changeset	256 static address throw_StackOverflowError_entry() { return _throw_StackOverflowError_entry; }
3781 d83ac25d0304 7055355: JSR 292: crash while throwing WrongMethodTypeException never parents: 2446 diff changeset	257 static address throw_WrongMethodTypeException_entry() { return _throw_WrongMethodTypeException_entry; }
0 a61af66fc99e Initial load duke parents: diff changeset	258
a61af66fc99e Initial load duke parents: diff changeset	259 // Exceptions during unsafe access - should throw Java exception rather
a61af66fc99e Initial load duke parents: diff changeset	260 // than crash.
a61af66fc99e Initial load duke parents: diff changeset	261 static address handler_for_unsafe_access() { return _handler_for_unsafe_access_entry; }
a61af66fc99e Initial load duke parents: diff changeset	262
a61af66fc99e Initial load duke parents: diff changeset	263 static address atomic_xchg_entry() { return _atomic_xchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	264 static address atomic_xchg_ptr_entry() { return _atomic_xchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	265 static address atomic_store_entry() { return _atomic_store_entry; }
a61af66fc99e Initial load duke parents: diff changeset	266 static address atomic_store_ptr_entry() { return _atomic_store_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	267 static address atomic_cmpxchg_entry() { return _atomic_cmpxchg_entry; }
a61af66fc99e Initial load duke parents: diff changeset	268 static address atomic_cmpxchg_ptr_entry() { return _atomic_cmpxchg_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	269 static address atomic_cmpxchg_long_entry() { return _atomic_cmpxchg_long_entry; }
a61af66fc99e Initial load duke parents: diff changeset	270 static address atomic_add_entry() { return _atomic_add_entry; }
a61af66fc99e Initial load duke parents: diff changeset	271 static address atomic_add_ptr_entry() { return _atomic_add_ptr_entry; }
a61af66fc99e Initial load duke parents: diff changeset	272 static address fence_entry() { return _fence_entry; }
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 static address d2i_wrapper() { return _d2i_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	275 static address d2l_wrapper() { return _d2l_wrapper; }
a61af66fc99e Initial load duke parents: diff changeset	276 static jint fpu_cntrl_wrd_std() { return _fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	277 static address addr_fpu_cntrl_wrd_std() { return (address)&_fpu_cntrl_wrd_std; }
a61af66fc99e Initial load duke parents: diff changeset	278 static address addr_fpu_cntrl_wrd_24() { return (address)&_fpu_cntrl_wrd_24; }
a61af66fc99e Initial load duke parents: diff changeset	279 static address addr_fpu_cntrl_wrd_64() { return (address)&_fpu_cntrl_wrd_64; }
a61af66fc99e Initial load duke parents: diff changeset	280 static address addr_fpu_cntrl_wrd_trunc() { return (address)&_fpu_cntrl_wrd_trunc; }
a61af66fc99e Initial load duke parents: diff changeset	281 static address addr_mxcsr_std() { return (address)&_mxcsr_std; }
a61af66fc99e Initial load duke parents: diff changeset	282 static address addr_fpu_subnormal_bias1() { return (address)&_fpu_subnormal_bias1; }
a61af66fc99e Initial load duke parents: diff changeset	283 static address addr_fpu_subnormal_bias2() { return (address)&_fpu_subnormal_bias2; }
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285
2446 13bc79b5c9c8 7033154: Improve C1 arraycopy performance roland parents: 2324 diff changeset	286 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	287
0 a61af66fc99e Initial load duke parents: diff changeset	288 static address jbyte_arraycopy() { return _jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	289 static address jshort_arraycopy() { return _jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	290 static address jint_arraycopy() { return _jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	291 static address jlong_arraycopy() { return _jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	292 static address oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	293 return dest_uninitialized ? _oop_arraycopy_uninit : _oop_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	294 }
0 a61af66fc99e Initial load duke parents: diff changeset	295 static address jbyte_disjoint_arraycopy() { return _jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	296 static address jshort_disjoint_arraycopy() { return _jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	297 static address jint_disjoint_arraycopy() { return _jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	298 static address jlong_disjoint_arraycopy() { return _jlong_disjoint_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	299 static address oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	300 return dest_uninitialized ? _oop_disjoint_arraycopy_uninit : _oop_disjoint_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	301 }
0 a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 static address arrayof_jbyte_arraycopy() { return _arrayof_jbyte_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	304 static address arrayof_jshort_arraycopy() { return _arrayof_jshort_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	305 static address arrayof_jint_arraycopy() { return _arrayof_jint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	306 static address arrayof_jlong_arraycopy() { return _arrayof_jlong_arraycopy; }
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	307 static address arrayof_oop_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	308 return dest_uninitialized ? _arrayof_oop_arraycopy_uninit : _arrayof_oop_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	309 }
0 a61af66fc99e Initial load duke parents: diff changeset	310
a61af66fc99e Initial load duke parents: diff changeset	311 static address arrayof_jbyte_disjoint_arraycopy() { return _arrayof_jbyte_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	312 static address arrayof_jshort_disjoint_arraycopy() { return _arrayof_jshort_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	313 static address arrayof_jint_disjoint_arraycopy() { return _arrayof_jint_disjoint_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	314 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	315 static address arrayof_oop_disjoint_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	316 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	317 }
0 a61af66fc99e Initial load duke parents: diff changeset	318
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	319 static address checkcast_arraycopy(bool dest_uninitialized = false) {
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	320 return dest_uninitialized ? _checkcast_arraycopy_uninit : _checkcast_arraycopy;
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	321 }
0 a61af66fc99e Initial load duke parents: diff changeset	322 static address unsafe_arraycopy() { return _unsafe_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	323 static address generic_arraycopy() { return _generic_arraycopy; }
a61af66fc99e Initial load duke parents: diff changeset	324
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	325 static address jbyte_fill() { return _jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	326 static address jshort_fill() { return _jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	327 static address jint_fill() { return _jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	328 static address arrayof_jbyte_fill() { return _arrayof_jbyte_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	329 static address arrayof_jshort_fill() { return _arrayof_jshort_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	330 static address arrayof_jint_fill() { return _arrayof_jint_fill; }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	331
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	332 static address select_fill_function(BasicType t, bool aligned, const char* &name);
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	333
3892 baf763f388e6 7059037: Use BIS for zeroing on T4 kvn parents: 3781 diff changeset	334 static address zero_aligned_words() { return _zero_aligned_words; }
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1552 diff changeset	335
1174 ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	336 static double intrinsic_log(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	337 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	338 return _intrinsic_log(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	339 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	340 static double intrinsic_log10(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	341 assert(_intrinsic_log != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	342 return _intrinsic_log10(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	343 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	344 static double intrinsic_exp(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	345 assert(_intrinsic_exp != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	346 return _intrinsic_exp(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	347 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	348 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	349 assert(_intrinsic_pow != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	350 return _intrinsic_pow(d, d2);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	351 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	352 static double intrinsic_sin(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	353 assert(_intrinsic_sin != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	354 return _intrinsic_sin(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	355 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	356 static double intrinsic_cos(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	357 assert(_intrinsic_cos != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	358 return _intrinsic_cos(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	359 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	360 static double intrinsic_tan(double d) {
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	361 assert(_intrinsic_tan != NULL, "must be defined");
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	362 return _intrinsic_tan(d);
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	363 }
ddb7834449d0 6849984: Value methods for platform dependent math functions constant fold incorrectly never parents: 16 diff changeset	364
0 a61af66fc99e Initial load duke parents: diff changeset	365 //
a61af66fc99e Initial load duke parents: diff changeset	366 // Default versions of the above arraycopy functions for platforms which do
a61af66fc99e Initial load duke parents: diff changeset	367 // not have specialized versions
a61af66fc99e Initial load duke parents: diff changeset	368 //
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	369 static void jbyte_copy (jbyte* src, jbyte* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	370 static void jshort_copy (jshort* src, jshort* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	371 static void jint_copy (jint* src, jint* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	372 static void jlong_copy (jlong* src, jlong* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	373 static void oop_copy (oop* src, oop* dest, size_t count);
0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	374 static void oop_copy_uninit(oop* src, oop* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	375
2324 0ac769a57c64 6627983: G1: Bad oop deference during marking iveresov parents: 2192 diff changeset	376 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	377 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	378 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	379 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	380 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	381 static void arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count);
0 a61af66fc99e Initial load duke parents: diff changeset	382 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	383
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	384 #endif // SHARE_VM_RUNTIME_STUBROUTINES_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/runtime/stubRoutines.hpp @ 3979:4dfb2df418f2