hotspot/src/share/vm/runtime/stubRoutines.cpp
author ctornqvi
Wed, 04 May 2016 15:32:26 -0400
changeset 38190 ff9ac612c723
parent 38174 f611c50b8703
child 38209 b2a58604e046
permissions -rw-r--r--
8156066: Backout JDK-8153892 Reviewed-by: coleenp, mikael
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
36178
9739f8c767da 8148630: Convert TraceStartupTime to Unified Logging
rprotacio
parents: 35540
diff changeset
     2
 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    26
#include "asm/codeBuffer.hpp"
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
    27
#include "code/codeCacheExtensions.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    28
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    29
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    30
#include "runtime/interfaceSupport.hpp"
37161
e881f320966e 8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents: 36178
diff changeset
    31
#include "runtime/timerTrace.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    32
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    33
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    34
#include "utilities/copy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    35
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    36
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6434
diff changeset
    37
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// Implementation of StubRoutines - for a description
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// of how to extend it, see the header file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// Class Variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
BufferBlob* StubRoutines::_code1                                = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
BufferBlob* StubRoutines::_code2                                = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
address StubRoutines::_call_stub_return_address                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
address StubRoutines::_call_stub_entry                          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
address StubRoutines::_catch_exception_entry                    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
address StubRoutines::_forward_exception_entry                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
address StubRoutines::_throw_AbstractMethodError_entry          = NULL;
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
    54
address StubRoutines::_throw_IncompatibleClassChangeError_entry = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
address StubRoutines::_throw_NullPointerException_at_call_entry = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
address StubRoutines::_throw_StackOverflowError_entry           = NULL;
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33485
diff changeset
    57
address StubRoutines::_throw_delayed_StackOverflowError_entry   = NULL;
38190
ff9ac612c723 8156066: Backout JDK-8153892
ctornqvi
parents: 38174
diff changeset
    58
address StubRoutines::_handler_for_unsafe_access_entry          = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
jint    StubRoutines::_verify_oop_count                         = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
address StubRoutines::_verify_oop_subroutine_entry              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
address StubRoutines::_atomic_xchg_entry                        = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
address StubRoutines::_atomic_xchg_ptr_entry                    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
address StubRoutines::_atomic_store_entry                       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
address StubRoutines::_atomic_store_ptr_entry                   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
address StubRoutines::_atomic_cmpxchg_entry                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
address StubRoutines::_atomic_cmpxchg_ptr_entry                 = NULL;
27691
733f189ad1f7 8058255: Native jbyte Atomic::cmpxchg for supported x86 platforms
jwilhelm
parents: 26434
diff changeset
    67
address StubRoutines::_atomic_cmpxchg_byte_entry                = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
address StubRoutines::_atomic_cmpxchg_long_entry                = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
address StubRoutines::_atomic_add_entry                         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
address StubRoutines::_atomic_add_ptr_entry                     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
address StubRoutines::_fence_entry                              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
address StubRoutines::_d2i_wrapper                              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
address StubRoutines::_d2l_wrapper                              = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
jint    StubRoutines::_fpu_cntrl_wrd_std                        = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
jint    StubRoutines::_fpu_cntrl_wrd_24                         = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
jint    StubRoutines::_fpu_cntrl_wrd_64                         = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
jint    StubRoutines::_fpu_cntrl_wrd_trunc                      = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
jint    StubRoutines::_mxcsr_std                                = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
jint    StubRoutines::_fpu_subnormal_bias1[3]                   = { 0, 0, 0 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
jint    StubRoutines::_fpu_subnormal_bias2[3]                   = { 0, 0, 0 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// Compiled code entry points default values
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
    84
// The default functions don't have separate disjoint versions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
address StubRoutines::_jbyte_arraycopy          = CAST_FROM_FN_PTR(address, StubRoutines::jbyte_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
address StubRoutines::_jshort_arraycopy         = CAST_FROM_FN_PTR(address, StubRoutines::jshort_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
address StubRoutines::_jint_arraycopy           = CAST_FROM_FN_PTR(address, StubRoutines::jint_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
address StubRoutines::_jlong_arraycopy          = CAST_FROM_FN_PTR(address, StubRoutines::jlong_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
address StubRoutines::_oop_arraycopy            = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy);
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
    90
address StubRoutines::_oop_arraycopy_uninit     = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy_uninit);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
address StubRoutines::_jbyte_disjoint_arraycopy          = CAST_FROM_FN_PTR(address, StubRoutines::jbyte_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
address StubRoutines::_jshort_disjoint_arraycopy         = CAST_FROM_FN_PTR(address, StubRoutines::jshort_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
address StubRoutines::_jint_disjoint_arraycopy           = CAST_FROM_FN_PTR(address, StubRoutines::jint_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
address StubRoutines::_jlong_disjoint_arraycopy          = CAST_FROM_FN_PTR(address, StubRoutines::jlong_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
address StubRoutines::_oop_disjoint_arraycopy            = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy);
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
    96
address StubRoutines::_oop_disjoint_arraycopy_uninit     = CAST_FROM_FN_PTR(address, StubRoutines::oop_copy_uninit);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
address StubRoutines::_arrayof_jbyte_arraycopy  = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jbyte_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
address StubRoutines::_arrayof_jshort_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jshort_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
address StubRoutines::_arrayof_jint_arraycopy   = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jint_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
address StubRoutines::_arrayof_jlong_arraycopy  = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jlong_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
address StubRoutines::_arrayof_oop_arraycopy    = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy);
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   103
address StubRoutines::_arrayof_oop_arraycopy_uninit      = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy_uninit);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
address StubRoutines::_arrayof_jbyte_disjoint_arraycopy  = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jbyte_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
address StubRoutines::_arrayof_jshort_disjoint_arraycopy = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jshort_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
address StubRoutines::_arrayof_jint_disjoint_arraycopy   = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jint_copy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
address StubRoutines::_arrayof_jlong_disjoint_arraycopy  = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_jlong_copy);
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   108
address StubRoutines::_arrayof_oop_disjoint_arraycopy    = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   109
address StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit  = CAST_FROM_FN_PTR(address, StubRoutines::arrayof_oop_copy_uninit);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   110
10501
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 10004
diff changeset
   111
address StubRoutines::_zero_aligned_words = CAST_FROM_FN_PTR(address, Copy::zero_to_words);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
address StubRoutines::_checkcast_arraycopy               = NULL;
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   114
address StubRoutines::_checkcast_arraycopy_uninit        = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
address StubRoutines::_unsafe_arraycopy                  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
address StubRoutines::_generic_arraycopy                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   118
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   119
address StubRoutines::_jbyte_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   120
address StubRoutines::_jshort_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   121
address StubRoutines::_jint_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   122
address StubRoutines::_arrayof_jbyte_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   123
address StubRoutines::_arrayof_jshort_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   124
address StubRoutines::_arrayof_jint_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   125
14132
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13974
diff changeset
   126
address StubRoutines::_aescrypt_encryptBlock               = NULL;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13974
diff changeset
   127
address StubRoutines::_aescrypt_decryptBlock               = NULL;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13974
diff changeset
   128
address StubRoutines::_cipherBlockChaining_encryptAESCrypt = NULL;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13974
diff changeset
   129
address StubRoutines::_cipherBlockChaining_decryptAESCrypt = NULL;
35154
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35146
diff changeset
   130
address StubRoutines::_counterMode_AESCrypt                = NULL;
31404
63e8fcd70bfc 8073108: Use x86 and SPARC CPU instructions for GHASH acceleration
ascarpino
parents: 31129
diff changeset
   131
address StubRoutines::_ghash_processBlocks                 = NULL;
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   132
24953
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   133
address StubRoutines::_sha1_implCompress     = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   134
address StubRoutines::_sha1_implCompressMB   = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   135
address StubRoutines::_sha256_implCompress   = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   136
address StubRoutines::_sha256_implCompressMB = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   137
address StubRoutines::_sha512_implCompress   = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   138
address StubRoutines::_sha512_implCompressMB = NULL;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 18740
diff changeset
   139
18507
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 17087
diff changeset
   140
address StubRoutines::_updateBytesCRC32 = NULL;
33066
d98eab8215c4 8134553: CRC32C implementations for x86/x64 targets
kvn
parents: 32581
diff changeset
   141
address StubRoutines::_crc_table_adr =    NULL;
18507
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 17087
diff changeset
   142
33066
d98eab8215c4 8134553: CRC32C implementations for x86/x64 targets
kvn
parents: 32581
diff changeset
   143
address StubRoutines::_crc32c_table_addr = NULL;
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31408
diff changeset
   144
address StubRoutines::_updateBytesCRC32C = NULL;
32581
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 32384
diff changeset
   145
address StubRoutines::_updateBytesAdler32 = NULL;
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31408
diff changeset
   146
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 24953
diff changeset
   147
address StubRoutines::_multiplyToLen = NULL;
31129
02ee7609f0e1 8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents: 30110
diff changeset
   148
address StubRoutines::_squareToLen = NULL;
02ee7609f0e1 8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents: 30110
diff changeset
   149
address StubRoutines::_mulAdd = NULL;
31583
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   150
address StubRoutines::_montgomeryMultiply = NULL;
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   151
address StubRoutines::_montgomerySquare = NULL;
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 24953
diff changeset
   152
35110
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   153
address StubRoutines::_vectorizedMismatch = NULL;
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   154
33089
f4e956ed8b43 8132207: update for x86 exp in the math lib
iveresov
parents: 33066
diff changeset
   155
address StubRoutines::_dexp = NULL;
33465
6063f28a6efb 8139575: Update for x86 log in the math lib
iveresov
parents: 33089
diff changeset
   156
address StubRoutines::_dlog = NULL;
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 36178
diff changeset
   157
address StubRoutines::_dlog10 = NULL;
35146
9ebfec283f56 8145688: Update for x86 pow in the math lib
kvn
parents: 35135
diff changeset
   158
address StubRoutines::_dpow = NULL;
35540
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   159
address StubRoutines::_dsin = NULL;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   160
address StubRoutines::_dcos = NULL;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   161
address StubRoutines::_dlibm_sin_cos_huge = NULL;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   162
address StubRoutines::_dlibm_reduce_pi04l = NULL;
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 36178
diff changeset
   163
address StubRoutines::_dlibm_tan_cot_huge = NULL;
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 36178
diff changeset
   164
address StubRoutines::_dtan = NULL;
33089
f4e956ed8b43 8132207: update for x86 exp in the math lib
iveresov
parents: 33066
diff changeset
   165
4645
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   166
double (* StubRoutines::_intrinsic_log10 )(double) = NULL;
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   167
double (* StubRoutines::_intrinsic_sin   )(double) = NULL;
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   168
double (* StubRoutines::_intrinsic_cos   )(double) = NULL;
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   169
double (* StubRoutines::_intrinsic_tan   )(double) = NULL;
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   170
18740
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   171
address StubRoutines::_safefetch32_entry                 = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   172
address StubRoutines::_safefetch32_fault_pc              = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   173
address StubRoutines::_safefetch32_continuation_pc       = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   174
address StubRoutines::_safefetchN_entry                  = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   175
address StubRoutines::_safefetchN_fault_pc               = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   176
address StubRoutines::_safefetchN_continuation_pc        = NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   177
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
// Initialization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
// Note: to break cycle with universe initialization, stubs are generated in two phases.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
// The first one generates stubs needed during universe init (e.g., _handle_must_compile_first_entry).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
// The second phase includes all other stubs (which may depend on universe being initialized.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
extern void StubGenerator_generate(CodeBuffer* code, bool all); // only interface to generators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
void StubRoutines::initialize1() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  if (_code1 == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    ResourceMark rm;
37161
e881f320966e 8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents: 36178
diff changeset
   189
    TraceTime timer("StubRoutines generation 1", TRACETIME_LOG(Info, startuptime));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    _code1 = BufferBlob::create("StubRoutines (1)", code_size1);
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4886
diff changeset
   191
    if (_code1 == NULL) {
17087
f0b76c4c93a0 8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents: 14132
diff changeset
   192
      vm_exit_out_of_memory(code_size1, OOM_MALLOC_ERROR, "CodeCache: no room for StubRoutines (1)");
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4886
diff changeset
   193
    }
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 5883
diff changeset
   194
    CodeBuffer buffer(_code1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    StubGenerator_generate(&buffer, false);
31408
73a4dd2fcd43 8080157: assert(allocates2(pc)) failed: not in CodeBuffer memory
kvn
parents: 31404
diff changeset
   196
    // When new stubs added we need to make sure there is some space left
73a4dd2fcd43 8080157: assert(allocates2(pc)) failed: not in CodeBuffer memory
kvn
parents: 31404
diff changeset
   197
    // to catch situation when we should increase size again.
32384
d28b2b792dba 8133951: Zero interpreter asserts in stubRoutines.cpp
coleenp
parents: 31635
diff changeset
   198
    assert(code_size1 == 0 || buffer.insts_remaining() > 200, "increase code_size1");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
typedef void (*arraycopy_fn)(address src, address dst, int count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
// simple tests of generated arraycopy functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
static void test_arraycopy_func(address func, int alignment) {
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   208
  if (CodeCacheExtensions::use_pregenerated_interpreter() || !CodeCacheExtensions::is_executable(func)) {
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   209
    // Exit safely if stubs were generated but cannot be used.
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   210
    // Also excluding pregenerated interpreter since the code may depend on
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   211
    // some registers being properly initialized (for instance Rthread)
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   212
    return;
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 31129
diff changeset
   213
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  int v = 0xcc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  int v2 = 0x11;
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   216
  jlong lbuffer[8];
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   217
  jlong lbuffer2[8];
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   218
  address fbuffer  = (address) lbuffer;
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   219
  address fbuffer2 = (address) lbuffer2;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  unsigned int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  for (i = 0; i < sizeof(lbuffer); i++) {
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   222
    fbuffer[i] = v; fbuffer2[i] = v2;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  }
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   224
  // C++ does not guarantee jlong[] array alignment to 8 bytes.
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   225
  // Use middle of array to check that memory before it is not modified.
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   226
  address buffer  = (address) round_to((intptr_t)&lbuffer[4], BytesPerLong);
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   227
  address buffer2 = (address) round_to((intptr_t)&lbuffer2[4], BytesPerLong);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  // do an aligned copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  ((arraycopy_fn)func)(buffer, buffer2, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  for (i = 0; i < sizeof(lbuffer); i++) {
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   231
    assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  // adjust destination alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  ((arraycopy_fn)func)(buffer, buffer2 + alignment, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  for (i = 0; i < sizeof(lbuffer); i++) {
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   236
    assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // adjust source alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  ((arraycopy_fn)func)(buffer + alignment, buffer2, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  for (i = 0; i < sizeof(lbuffer); i++) {
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   241
    assert(fbuffer[i] == v && fbuffer2[i] == v2, "shouldn't have copied anything");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
}
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   244
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   245
// simple test for SafeFetch32
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   246
static void test_safefetch32() {
30110
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   247
  if (CanUseSafeFetch32()) {
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   248
    int dummy = 17;
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   249
    int* const p_invalid = (int*) get_segfault_address();
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   250
    int* const p_valid = &dummy;
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   251
    int result_invalid = SafeFetch32(p_invalid, 0xABC);
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   252
    assert(result_invalid == 0xABC, "SafeFetch32 error");
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   253
    int result_valid = SafeFetch32(p_valid, 0xABC);
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   254
    assert(result_valid == 17, "SafeFetch32 error");
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   255
  }
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   256
}
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   257
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   258
// simple test for SafeFetchN
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   259
static void test_safefetchN() {
30110
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   260
  if (CanUseSafeFetchN()) {
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   261
#ifdef _LP64
30110
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   262
    const intptr_t v1 = UCONST64(0xABCD00000000ABCD);
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   263
    const intptr_t v2 = UCONST64(0xDEFD00000000DEFD);
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   264
#else
30110
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   265
    const intptr_t v1 = 0xABCDABCD;
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   266
    const intptr_t v2 = 0xDEFDDEFD;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
#endif
30110
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   268
    intptr_t dummy = v1;
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   269
    intptr_t* const p_invalid = (intptr_t*) get_segfault_address();
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   270
    intptr_t* const p_valid = &dummy;
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   271
    intptr_t result_invalid = SafeFetchN(p_invalid, v2);
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   272
    assert(result_invalid == v2, "SafeFetchN error");
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   273
    intptr_t result_valid = SafeFetchN(p_valid, v2);
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   274
    assert(result_valid == v1, "SafeFetchN error");
20d4dc1409a6 8075533: Zero JVM segfaults for -version after JDK-8074552
sgehwolf
parents: 29573
diff changeset
   275
  }
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   276
}
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   277
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
void StubRoutines::initialize2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  if (_code2 == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    ResourceMark rm;
37161
e881f320966e 8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents: 36178
diff changeset
   282
    TraceTime timer("StubRoutines generation 2", TRACETIME_LOG(Info, startuptime));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    _code2 = BufferBlob::create("StubRoutines (2)", code_size2);
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4886
diff changeset
   284
    if (_code2 == NULL) {
17087
f0b76c4c93a0 8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents: 14132
diff changeset
   285
      vm_exit_out_of_memory(code_size2, OOM_MALLOC_ERROR, "CodeCache: no room for StubRoutines (2)");
5403
6b0dd9c75dde 6888954: argument formatting for assert() and friends
jcoomes
parents: 4886
diff changeset
   286
    }
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 5883
diff changeset
   287
    CodeBuffer buffer(_code2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    StubGenerator_generate(&buffer, true);
31408
73a4dd2fcd43 8080157: assert(allocates2(pc)) failed: not in CodeBuffer memory
kvn
parents: 31404
diff changeset
   289
    // When new stubs added we need to make sure there is some space left
73a4dd2fcd43 8080157: assert(allocates2(pc)) failed: not in CodeBuffer memory
kvn
parents: 31404
diff changeset
   290
    // to catch situation when we should increase size again.
32384
d28b2b792dba 8133951: Zero interpreter asserts in stubRoutines.cpp
coleenp
parents: 31635
diff changeset
   291
    assert(code_size2 == 0 || buffer.insts_remaining() > 200, "increase code_size2");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
#define TEST_ARRAYCOPY(type)                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  test_arraycopy_func(          type##_arraycopy(),          sizeof(type));     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  test_arraycopy_func(          type##_disjoint_arraycopy(), sizeof(type));     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  test_arraycopy_func(arrayof_##type##_arraycopy(),          sizeof(HeapWord)); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  test_arraycopy_func(arrayof_##type##_disjoint_arraycopy(), sizeof(HeapWord))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   302
  // Make sure all the arraycopy stubs properly handle zero count
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  TEST_ARRAYCOPY(jbyte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  TEST_ARRAYCOPY(jshort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  TEST_ARRAYCOPY(jint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  TEST_ARRAYCOPY(jlong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
#undef TEST_ARRAYCOPY
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   310
#define TEST_FILL(type)                                                                      \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   311
  if (_##type##_fill != NULL) {                                                              \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   312
    union {                                                                                  \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   313
      double d;                                                                              \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   314
      type body[96];                                                                         \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   315
    } s;                                                                                     \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   316
                                                                                             \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   317
    int v = 32;                                                                              \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   318
    for (int offset = -2; offset <= 2; offset++) {                                           \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   319
      for (int i = 0; i < 96; i++) {                                                         \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   320
        s.body[i] = 1;                                                                       \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   321
      }                                                                                      \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   322
      type* start = s.body + 8 + offset;                                                     \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   323
      for (int aligned = 0; aligned < 2; aligned++) {                                        \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   324
        if (aligned) {                                                                       \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   325
          if (((intptr_t)start) % HeapWordSize == 0) {                                       \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   326
            ((void (*)(type*, int, int))StubRoutines::_arrayof_##type##_fill)(start, v, 80); \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   327
          } else {                                                                           \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   328
            continue;                                                                        \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   329
          }                                                                                  \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   330
        } else {                                                                             \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   331
          ((void (*)(type*, int, int))StubRoutines::_##type##_fill)(start, v, 80);           \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   332
        }                                                                                    \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   333
        for (int i = 0; i < 96; i++) {                                                       \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   334
          if (i < (8 + offset) || i >= (88 + offset)) {                                      \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   335
            assert(s.body[i] == 1, "what?");                                                 \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   336
          } else {                                                                           \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   337
            assert(s.body[i] == 32, "what?");                                                \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   338
          }                                                                                  \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   339
        }                                                                                    \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   340
      }                                                                                      \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   341
    }                                                                                        \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   342
  }                                                                                          \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   343
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   344
  TEST_FILL(jbyte);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   345
  TEST_FILL(jshort);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   346
  TEST_FILL(jint);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   347
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   348
#undef TEST_FILL
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   349
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   350
#define TEST_COPYRTN(type) \
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   351
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::conjoint_##type##s_atomic),  sizeof(type)); \
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   352
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::arrayof_conjoint_##type##s), (int)MAX2(sizeof(HeapWord), sizeof(type)))
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   353
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   354
  // Make sure all the copy runtime routines properly handle zero count
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   355
  TEST_COPYRTN(jbyte);
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   356
  TEST_COPYRTN(jshort);
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   357
  TEST_COPYRTN(jint);
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   358
  TEST_COPYRTN(jlong);
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   359
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   360
#undef TEST_COPYRTN
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   361
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   362
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::conjoint_words), sizeof(HeapWord));
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   363
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::disjoint_words), sizeof(HeapWord));
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   364
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::disjoint_words_atomic), sizeof(HeapWord));
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   365
  // Aligned to BytesPerLong
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   366
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::aligned_conjoint_words), sizeof(jlong));
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   367
  test_arraycopy_func(CAST_FROM_FN_PTR(address, Copy::aligned_disjoint_words), sizeof(jlong));
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   368
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   369
  // test safefetch routines
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   370
  // Not on Windows 32bit until 8074860 is fixed
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   371
#if ! (defined(_WIN32) && defined(_M_IX86))
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   372
  test_safefetch32();
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   373
  test_safefetchN();
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   374
#endif
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 27691
diff changeset
   375
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
void stubRoutines_init1() { StubRoutines::initialize1(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
void stubRoutines_init2() { StubRoutines::initialize2(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
// Default versions of arraycopy functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   387
static void gen_arraycopy_barrier_pre(oop* dest, size_t count, bool dest_uninitialized) {
4886
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   388
    assert(count != 0, "count should be non-zero");
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   389
    assert(count <= (size_t)max_intx, "count too large");
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   390
    BarrierSet* bs = Universe::heap()->barrier_set();
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   391
    assert(bs->has_write_ref_array_pre_opt(), "Must have pre-barrier opt");
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   392
    bs->write_ref_array_pre(dest, (int)count, dest_uninitialized);
4886
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   393
}
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   394
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
static void gen_arraycopy_barrier(oop* dest, size_t count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    assert(count != 0, "count should be non-zero");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    BarrierSet* bs = Universe::heap()->barrier_set();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
4886
a2f9a66475b3 6904516: More object array barrier fixes, following up on 6906727
ysr
parents: 4645
diff changeset
   399
    bs->write_ref_array((HeapWord*)dest, count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
JRT_LEAF(void, StubRoutines::jbyte_copy(jbyte* src, jbyte* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  SharedRuntime::_jbyte_array_copy_ctr++;      // Slow-path byte array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
#endif // !PRODUCT
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   406
  Copy::conjoint_jbytes_atomic(src, dest, count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
JRT_LEAF(void, StubRoutines::jshort_copy(jshort* src, jshort* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  SharedRuntime::_jshort_array_copy_ctr++;     // Slow-path short/char array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  Copy::conjoint_jshorts_atomic(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
JRT_LEAF(void, StubRoutines::jint_copy(jint* src, jint* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  SharedRuntime::_jint_array_copy_ctr++;       // Slow-path int/float array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  Copy::conjoint_jints_atomic(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
JRT_LEAF(void, StubRoutines::jlong_copy(jlong* src, jlong* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  SharedRuntime::_jlong_array_copy_ctr++;      // Slow-path long/double array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  Copy::conjoint_jlongs_atomic(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
JRT_LEAF(void, StubRoutines::oop_copy(oop* src, oop* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  SharedRuntime::_oop_array_copy_ctr++;        // Slow-path oop array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  assert(count != 0, "count should be non-zero");
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   435
  gen_arraycopy_barrier_pre(dest, count, /*dest_uninitialized*/false);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   436
  Copy::conjoint_oops_atomic(src, dest, count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   437
  gen_arraycopy_barrier(dest, count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   438
JRT_END
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   439
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   440
JRT_LEAF(void, StubRoutines::oop_copy_uninit(oop* src, oop* dest, size_t count))
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   441
#ifndef PRODUCT
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   442
  SharedRuntime::_oop_array_copy_ctr++;        // Slow-path oop array copy
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   443
#endif // !PRODUCT
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   444
  assert(count != 0, "count should be non-zero");
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   445
  gen_arraycopy_barrier_pre(dest, count, /*dest_uninitialized*/true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  Copy::conjoint_oops_atomic(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  gen_arraycopy_barrier(dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
JRT_LEAF(void, StubRoutines::arrayof_jbyte_copy(HeapWord* src, HeapWord* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  SharedRuntime::_jbyte_array_copy_ctr++;      // Slow-path byte array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
#endif // !PRODUCT
5883
8dc4bdc132d5 6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents: 5547
diff changeset
   454
  Copy::arrayof_conjoint_jbytes(src, dest, count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
JRT_LEAF(void, StubRoutines::arrayof_jshort_copy(HeapWord* src, HeapWord* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  SharedRuntime::_jshort_array_copy_ctr++;     // Slow-path short/char array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  Copy::arrayof_conjoint_jshorts(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
JRT_LEAF(void, StubRoutines::arrayof_jint_copy(HeapWord* src, HeapWord* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  SharedRuntime::_jint_array_copy_ctr++;       // Slow-path int/float array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  Copy::arrayof_conjoint_jints(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
JRT_LEAF(void, StubRoutines::arrayof_jlong_copy(HeapWord* src, HeapWord* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  SharedRuntime::_jlong_array_copy_ctr++;       // Slow-path int/float array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  Copy::arrayof_conjoint_jlongs(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
JRT_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
JRT_LEAF(void, StubRoutines::arrayof_oop_copy(HeapWord* src, HeapWord* dest, size_t count))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  SharedRuntime::_oop_array_copy_ctr++;        // Slow-path oop array copy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  assert(count != 0, "count should be non-zero");
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   483
  gen_arraycopy_barrier_pre((oop *) dest, count, /*dest_uninitialized*/false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  Copy::arrayof_conjoint_oops(src, dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  gen_arraycopy_barrier((oop *) dest, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
JRT_END
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   487
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   488
JRT_LEAF(void, StubRoutines::arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count))
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   489
#ifndef PRODUCT
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   490
  SharedRuntime::_oop_array_copy_ctr++;        // Slow-path oop array copy
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   491
#endif // !PRODUCT
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   492
  assert(count != 0, "count should be non-zero");
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   493
  gen_arraycopy_barrier_pre((oop *) dest, count, /*dest_uninitialized*/true);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   494
  Copy::arrayof_conjoint_oops(src, dest, count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   495
  gen_arraycopy_barrier((oop *) dest, count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 7397
diff changeset
   496
JRT_END
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   497
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   498
address StubRoutines::select_fill_function(BasicType t, bool aligned, const char* &name) {
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   499
#define RETURN_STUB(xxx_fill) { \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   500
  name = #xxx_fill; \
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   501
  return StubRoutines::xxx_fill(); }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   502
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   503
  switch (t) {
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   504
  case T_BYTE:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   505
  case T_BOOLEAN:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   506
    if (!aligned) RETURN_STUB(jbyte_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   507
    RETURN_STUB(arrayof_jbyte_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   508
  case T_CHAR:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   509
  case T_SHORT:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   510
    if (!aligned) RETURN_STUB(jshort_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   511
    RETURN_STUB(arrayof_jshort_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   512
  case T_INT:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   513
  case T_FLOAT:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   514
    if (!aligned) RETURN_STUB(jint_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   515
    RETURN_STUB(arrayof_jint_fill);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   516
  case T_DOUBLE:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   517
  case T_LONG:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   518
  case T_ARRAY:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   519
  case T_OBJECT:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   520
  case T_NARROWOOP:
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13391
diff changeset
   521
  case T_NARROWKLASS:
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   522
  case T_ADDRESS:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   523
    // Currently unsupported
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   524
    return NULL;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   525
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   526
  default:
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   527
    ShouldNotReachHere();
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   528
    return NULL;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   529
  }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   530
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   531
#undef RETURN_STUB
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5883
diff changeset
   532
}
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   533
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   534
// constants for computing the copy function
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   535
enum {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   536
  COPYFUNC_UNALIGNED = 0,
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   537
  COPYFUNC_ALIGNED = 1,                 // src, dest aligned to HeapWordSize
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   538
  COPYFUNC_CONJOINT = 0,
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   539
  COPYFUNC_DISJOINT = 2                 // src != dest, or transfer can descend
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   540
};
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   541
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   542
// Note:  The condition "disjoint" applies also for overlapping copies
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   543
// where an descending copy is permitted (i.e., dest_offset <= src_offset).
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   544
address
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   545
StubRoutines::select_arraycopy_function(BasicType t, bool aligned, bool disjoint, const char* &name, bool dest_uninitialized) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   546
  int selector =
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   547
    (aligned  ? COPYFUNC_ALIGNED  : COPYFUNC_UNALIGNED) +
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   548
    (disjoint ? COPYFUNC_DISJOINT : COPYFUNC_CONJOINT);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   549
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   550
#define RETURN_STUB(xxx_arraycopy) { \
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   551
  name = #xxx_arraycopy; \
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   552
  return StubRoutines::xxx_arraycopy(); }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   553
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   554
#define RETURN_STUB_PARM(xxx_arraycopy, parm) {           \
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   555
  name = #xxx_arraycopy; \
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   556
  return StubRoutines::xxx_arraycopy(parm); }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   557
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   558
  switch (t) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   559
  case T_BYTE:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   560
  case T_BOOLEAN:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   561
    switch (selector) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   562
    case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jbyte_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   563
    case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jbyte_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   564
    case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jbyte_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   565
    case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jbyte_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   566
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   567
  case T_CHAR:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   568
  case T_SHORT:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   569
    switch (selector) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   570
    case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jshort_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   571
    case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jshort_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   572
    case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jshort_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   573
    case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jshort_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   574
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   575
  case T_INT:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   576
  case T_FLOAT:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   577
    switch (selector) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   578
    case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   579
    case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   580
    case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jint_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   581
    case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jint_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   582
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   583
  case T_DOUBLE:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   584
  case T_LONG:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   585
    switch (selector) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   586
    case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jlong_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   587
    case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jlong_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   588
    case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB(jlong_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   589
    case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB(arrayof_jlong_disjoint_arraycopy);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   590
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   591
  case T_ARRAY:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   592
  case T_OBJECT:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   593
    switch (selector) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   594
    case COPYFUNC_CONJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB_PARM(oop_arraycopy, dest_uninitialized);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   595
    case COPYFUNC_CONJOINT | COPYFUNC_ALIGNED:    RETURN_STUB_PARM(arrayof_oop_arraycopy, dest_uninitialized);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   596
    case COPYFUNC_DISJOINT | COPYFUNC_UNALIGNED:  RETURN_STUB_PARM(oop_disjoint_arraycopy, dest_uninitialized);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   597
    case COPYFUNC_DISJOINT | COPYFUNC_ALIGNED:    RETURN_STUB_PARM(arrayof_oop_disjoint_arraycopy, dest_uninitialized);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   598
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   599
  default:
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   600
    ShouldNotReachHere();
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   601
    return NULL;
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   602
  }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   603
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   604
#undef RETURN_STUB
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   605
#undef RETURN_STUB_PARM
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   606
}