src/hotspot/share/runtime/stubRoutines.hpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46597 hotspot/src/share/vm/runtime/stubRoutines.hpp@d669fb842ae3
child 47634 6a0c42c40cd1
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38051
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: 4645
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4645
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: 4645
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: 6433
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_STUBROUTINES_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    26
#define SHARE_VM_RUNTIME_STUBROUTINES_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    28
#include "code/codeBlob.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    29
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    30
#include "runtime/frame.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    31
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    32
#include "runtime/stubCodeGenerator.hpp"
40010
e32d5e545789 8161258: Simplify including platform files.
goetz
parents: 38209
diff changeset
    33
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    34
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// StubRoutines provides entry points to assembly routines used by
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// compiled code and the run-time system. Platform-specific entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// points are defined in the platform-specific inner class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Class scheme:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//    platform-independent               platform-dependent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//    stubRoutines.hpp  <-- included --  stubRoutines_<arch>.hpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//           ^                                  ^
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//           |                                  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//       implements                         implements
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//           |                                  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//           |                                  |
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
//    stubRoutines.cpp                   stubRoutines_<arch>.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
//    stubRoutines_<os_family>.cpp       stubGenerator_<arch>.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//    stubRoutines_<os_arch>.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// Note 1: The important thing is a clean decoupling between stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
//         entry points (interfacing to the whole vm; i.e., 1-to-n
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
//         relationship) and stub generators (interfacing only to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//         the entry points implementation; i.e., 1-to-1 relationship).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
//         This significantly simplifies changes in the generator
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
//         structure since the rest of the vm is not affected.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// Note 2: stubGenerator_<arch>.cpp contains a minimal portion of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//         machine-independent code; namely the generator calls of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//         the generator functions that are used platform-independently.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
//         However, it comes with the advantage of having a 1-file
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//         implementation of the generator. It should be fairly easy
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
//         to change, should it become a problem later.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
// Scheme for adding a new entry point:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// 1. determine if it's a platform-dependent or independent entry point
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
//    a) if platform independent: make subsequent changes in the independent files
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
//    b) if platform   dependent: make subsequent changes in the   dependent files
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// 2. add a private instance variable holding the entry point address
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// 3. add a public accessor function to the instance variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// 4. implement the corresponding generator function in the platform-dependent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
//    stubGenerator_<arch>.cpp file and call the function in generate_all() of that file
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
class StubRoutines: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  enum platform_independent_constants {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    max_size_of_parameters = 256                           // max. parameter size supported by megamorphic lookups
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // Dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  friend class StubGenerator;
40010
e32d5e545789 8161258: Simplify including platform files.
goetz
parents: 38209
diff changeset
    87
e32d5e545789 8161258: Simplify including platform files.
goetz
parents: 38209
diff changeset
    88
#include CPU_HEADER(stubRoutines)
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
    89
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  static jint    _verify_oop_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  static address _verify_oop_subroutine_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  static address _call_stub_return_address;                // the return PC, when returning to a call stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  static address _call_stub_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  static address _forward_exception_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  static address _catch_exception_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  static address _throw_AbstractMethodError_entry;
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
    98
  static address _throw_IncompatibleClassChangeError_entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  static address _throw_NullPointerException_at_call_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  static address _throw_StackOverflowError_entry;
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33485
diff changeset
   101
  static address _throw_delayed_StackOverflowError_entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  static address _atomic_xchg_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  static address _atomic_xchg_ptr_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  static address _atomic_store_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  static address _atomic_store_ptr_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  static address _atomic_cmpxchg_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  static address _atomic_cmpxchg_ptr_entry;
27691
733f189ad1f7 8058255: Native jbyte Atomic::cmpxchg for supported x86 platforms
jwilhelm
parents: 26434
diff changeset
   109
  static address _atomic_cmpxchg_byte_entry;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  static address _atomic_cmpxchg_long_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  static address _atomic_add_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  static address _atomic_add_ptr_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  static address _fence_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  static address _d2i_wrapper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  static address _d2l_wrapper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  static jint    _fpu_cntrl_wrd_std;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  static jint    _fpu_cntrl_wrd_24;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  static jint    _fpu_cntrl_wrd_64;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  static jint    _fpu_cntrl_wrd_trunc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  static jint    _mxcsr_std;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  static jint    _fpu_subnormal_bias1[3];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  static jint    _fpu_subnormal_bias2[3];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  static BufferBlob* _code1;                               // code buffer for initial routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  static BufferBlob* _code2;                               // code buffer for all other routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // Leaf routines which implement arraycopy and their addresses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // arraycopy operands aligned on element type boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  static address _jbyte_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  static address _jshort_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  static address _jint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  static address _jlong_arraycopy;
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   134
  static address _oop_arraycopy, _oop_arraycopy_uninit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  static address _jbyte_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  static address _jshort_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  static address _jint_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  static address _jlong_disjoint_arraycopy;
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   139
  static address _oop_disjoint_arraycopy, _oop_disjoint_arraycopy_uninit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // arraycopy operands aligned on zero'th element boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // These are identical to the ones aligned aligned on an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // element type boundary, except that they assume that both
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // source and destination are HeapWord aligned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  static address _arrayof_jbyte_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  static address _arrayof_jshort_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  static address _arrayof_jint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  static address _arrayof_jlong_arraycopy;
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   149
  static address _arrayof_oop_arraycopy, _arrayof_oop_arraycopy_uninit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  static address _arrayof_jbyte_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  static address _arrayof_jshort_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  static address _arrayof_jint_disjoint_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  static address _arrayof_jlong_disjoint_arraycopy;
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   154
  static address _arrayof_oop_disjoint_arraycopy, _arrayof_oop_disjoint_arraycopy_uninit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // these are recommended but optional:
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   157
  static address _checkcast_arraycopy, _checkcast_arraycopy_uninit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  static address _unsafe_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  static address _generic_arraycopy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   161
  static address _jbyte_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   162
  static address _jshort_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   163
  static address _jint_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   164
  static address _arrayof_jbyte_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   165
  static address _arrayof_jshort_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   166
  static address _arrayof_jint_fill;
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   167
10501
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 10004
diff changeset
   168
  // zero heap space aligned to jlong (8 bytes)
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 10004
diff changeset
   169
  static address _zero_aligned_words;
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 10004
diff changeset
   170
14132
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   171
  static address _aescrypt_encryptBlock;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   172
  static address _aescrypt_decryptBlock;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   173
  static address _cipherBlockChaining_encryptAESCrypt;
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   174
  static address _cipherBlockChaining_decryptAESCrypt;
35154
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35146
diff changeset
   175
  static address _counterMode_AESCrypt;
31404
63e8fcd70bfc 8073108: Use x86 and SPARC CPU instructions for GHASH acceleration
ascarpino
parents: 31129
diff changeset
   176
  static address _ghash_processBlocks;
14132
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   177
24953
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   178
  static address _sha1_implCompress;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   179
  static address _sha1_implCompressMB;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   180
  static address _sha256_implCompress;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   181
  static address _sha256_implCompressMB;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   182
  static address _sha512_implCompress;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   183
  static address _sha512_implCompressMB;
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   184
18507
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   185
  static address _updateBytesCRC32;
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   186
  static address _crc_table_adr;
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   187
33066
d98eab8215c4 8134553: CRC32C implementations for x86/x64 targets
kvn
parents: 32581
diff changeset
   188
  static address _crc32c_table_addr;
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31404
diff changeset
   189
  static address _updateBytesCRC32C;
32581
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 31584
diff changeset
   190
  static address _updateBytesAdler32;
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31404
diff changeset
   191
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 25715
diff changeset
   192
  static address _multiplyToLen;
31129
02ee7609f0e1 8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents: 30129
diff changeset
   193
  static address _squareToLen;
02ee7609f0e1 8081778: Use Intel x64 CPU instructions for RSA acceleration
kvn
parents: 30129
diff changeset
   194
  static address _mulAdd;
31583
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   195
  static address _montgomeryMultiply;
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   196
  static address _montgomerySquare;
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 25715
diff changeset
   197
35110
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   198
  static address _vectorizedMismatch;
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   199
33089
f4e956ed8b43 8132207: update for x86 exp in the math lib
iveresov
parents: 33066
diff changeset
   200
  static address _dexp;
33465
6063f28a6efb 8139575: Update for x86 log in the math lib
iveresov
parents: 33089
diff changeset
   201
  static address _dlog;
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 35540
diff changeset
   202
  static address _dlog10;
35146
9ebfec283f56 8145688: Update for x86 pow in the math lib
kvn
parents: 35135
diff changeset
   203
  static address _dpow;
35540
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   204
  static address _dsin;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   205
  static address _dcos;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   206
  static address _dlibm_sin_cos_huge;
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   207
  static address _dlibm_reduce_pi04l;
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 35540
diff changeset
   208
  static address _dlibm_tan_cot_huge;
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 35540
diff changeset
   209
  static address _dtan;
33089
f4e956ed8b43 8132207: update for x86 exp in the math lib
iveresov
parents: 33066
diff changeset
   210
4645
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   211
  // These are versions of the java.lang.Math methods which perform
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   212
  // the same operations as the intrinsic version.  They are used for
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   213
  // constant folding in the compiler to ensure equivalence.  If the
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   214
  // intrinsic version returns the same result as the strict version
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   215
  // then they can be set to the appropriate function from
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   216
  // SharedRuntime.
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   217
  static double (*_intrinsic_log10)(double);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   218
  static double (*_intrinsic_pow)(double, double);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   219
  static double (*_intrinsic_sin)(double);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   220
  static double (*_intrinsic_cos)(double);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   221
  static double (*_intrinsic_tan)(double);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   222
18740
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   223
  // Safefetch stubs.
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   224
  static address _safefetch32_entry;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   225
  static address _safefetch32_fault_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   226
  static address _safefetch32_continuation_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   227
  static address _safefetchN_entry;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   228
  static address _safefetchN_fault_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   229
  static address _safefetchN_continuation_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   230
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  // Initialization/Testing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  static void    initialize1();                            // must happen before universe::genesis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  static void    initialize2();                            // must happen after  universe::genesis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14132
diff changeset
   236
  static bool is_stub_code(address addr)                   { return contains(addr); }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14132
diff changeset
   237
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  static bool contains(address addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      (_code1 != NULL && _code1->blob_contains(addr)) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      (_code2 != NULL && _code2->blob_contains(addr)) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38051
diff changeset
   244
  static RuntimeBlob* code1() { return _code1; }
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38051
diff changeset
   245
  static RuntimeBlob* code2() { return _code2; }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 10545
diff changeset
   246
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // Debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  static jint    verify_oop_count()                        { return _verify_oop_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  static jint*   verify_oop_count_addr()                   { return &_verify_oop_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // a subroutine for debugging the GC
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   251
  static address verify_oop_subroutine_entry_address()     { return (address)&_verify_oop_subroutine_entry; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  static address catch_exception_entry()                   { return _catch_exception_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Calls to Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  typedef void (*CallStub)(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
    address   link,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    intptr_t* result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    BasicType result_type,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   260
    Method* method,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    address   entry_point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    intptr_t* parameters,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    int       size_of_parameters,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    TRAPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  static CallStub call_stub()                              { return CAST_TO_FN_PTR(CallStub, _call_stub_entry); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  // Exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  static address forward_exception_entry()                 { return _forward_exception_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // Implicit exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  static address throw_AbstractMethodError_entry()         { return _throw_AbstractMethodError_entry; }
189
4248c8e21063 6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents: 1
diff changeset
   273
  static address throw_IncompatibleClassChangeError_entry(){ return _throw_IncompatibleClassChangeError_entry; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  static address throw_NullPointerException_at_call_entry(){ return _throw_NullPointerException_at_call_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  static address throw_StackOverflowError_entry()          { return _throw_StackOverflowError_entry; }
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33485
diff changeset
   276
  static address throw_delayed_StackOverflowError_entry()  { return _throw_delayed_StackOverflowError_entry; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  static address atomic_xchg_entry()                       { return _atomic_xchg_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  static address atomic_xchg_ptr_entry()                   { return _atomic_xchg_ptr_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  static address atomic_store_entry()                      { return _atomic_store_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  static address atomic_store_ptr_entry()                  { return _atomic_store_ptr_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  static address atomic_cmpxchg_entry()                    { return _atomic_cmpxchg_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  static address atomic_cmpxchg_ptr_entry()                { return _atomic_cmpxchg_ptr_entry; }
27691
733f189ad1f7 8058255: Native jbyte Atomic::cmpxchg for supported x86 platforms
jwilhelm
parents: 26434
diff changeset
   284
  static address atomic_cmpxchg_byte_entry()               { return _atomic_cmpxchg_byte_entry; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  static address atomic_cmpxchg_long_entry()               { return _atomic_cmpxchg_long_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  static address atomic_add_entry()                        { return _atomic_add_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  static address atomic_add_ptr_entry()                    { return _atomic_add_ptr_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  static address fence_entry()                             { return _fence_entry; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  static address d2i_wrapper()                             { return _d2i_wrapper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  static address d2l_wrapper()                             { return _d2l_wrapper; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  static jint    fpu_cntrl_wrd_std()                       { return _fpu_cntrl_wrd_std;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  static address addr_fpu_cntrl_wrd_std()                  { return (address)&_fpu_cntrl_wrd_std;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  static address addr_fpu_cntrl_wrd_24()                   { return (address)&_fpu_cntrl_wrd_24;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  static address addr_fpu_cntrl_wrd_64()                   { return (address)&_fpu_cntrl_wrd_64;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  static address addr_fpu_cntrl_wrd_trunc()                { return (address)&_fpu_cntrl_wrd_trunc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  static address addr_mxcsr_std()                          { return (address)&_mxcsr_std; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  static address addr_fpu_subnormal_bias1()                { return (address)&_fpu_subnormal_bias1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  static address addr_fpu_subnormal_bias2()                { return (address)&_fpu_subnormal_bias2; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8498
diff changeset
   302
  static address 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
   303
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  static address jbyte_arraycopy()  { return _jbyte_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  static address jshort_arraycopy() { return _jshort_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  static address jint_arraycopy()   { return _jint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  static address jlong_arraycopy()  { return _jlong_arraycopy; }
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   308
  static address oop_arraycopy(bool dest_uninitialized = false) {
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   309
    return dest_uninitialized ? _oop_arraycopy_uninit : _oop_arraycopy;
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   310
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  static address jbyte_disjoint_arraycopy()  { return _jbyte_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  static address jshort_disjoint_arraycopy() { return _jshort_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  static address jint_disjoint_arraycopy()   { return _jint_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  static address jlong_disjoint_arraycopy()  { return _jlong_disjoint_arraycopy; }
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   315
  static address oop_disjoint_arraycopy(bool dest_uninitialized = false) {
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   316
    return dest_uninitialized ?  _oop_disjoint_arraycopy_uninit : _oop_disjoint_arraycopy;
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   317
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  static address arrayof_jbyte_arraycopy()  { return _arrayof_jbyte_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  static address arrayof_jshort_arraycopy() { return _arrayof_jshort_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  static address arrayof_jint_arraycopy()   { return _arrayof_jint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  static address arrayof_jlong_arraycopy()  { return _arrayof_jlong_arraycopy; }
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   323
  static address arrayof_oop_arraycopy(bool dest_uninitialized = false) {
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   324
    return dest_uninitialized ? _arrayof_oop_arraycopy_uninit : _arrayof_oop_arraycopy;
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   325
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  static address arrayof_jbyte_disjoint_arraycopy()  { return _arrayof_jbyte_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  static address arrayof_jshort_disjoint_arraycopy() { return _arrayof_jshort_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  static address arrayof_jint_disjoint_arraycopy()   { return _arrayof_jint_disjoint_arraycopy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  static address arrayof_jlong_disjoint_arraycopy()  { return _arrayof_jlong_disjoint_arraycopy; }
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   331
  static address arrayof_oop_disjoint_arraycopy(bool dest_uninitialized = false) {
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   332
    return dest_uninitialized ? _arrayof_oop_disjoint_arraycopy_uninit : _arrayof_oop_disjoint_arraycopy;
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   333
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   335
  static address checkcast_arraycopy(bool dest_uninitialized = false) {
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   336
    return dest_uninitialized ? _checkcast_arraycopy_uninit : _checkcast_arraycopy;
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   337
  }
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   338
  static address unsafe_arraycopy()    { return _unsafe_arraycopy; }
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   339
  static address generic_arraycopy()   { return _generic_arraycopy; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   341
  static address jbyte_fill()          { return _jbyte_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   342
  static address jshort_fill()         { return _jshort_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   343
  static address jint_fill()           { return _jint_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   344
  static address arrayof_jbyte_fill()  { return _arrayof_jbyte_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   345
  static address arrayof_jshort_fill() { return _arrayof_jshort_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   346
  static address arrayof_jint_fill()   { return _arrayof_jint_fill; }
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   347
14132
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   348
  static address aescrypt_encryptBlock()                { return _aescrypt_encryptBlock; }
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   349
  static address aescrypt_decryptBlock()                { return _aescrypt_decryptBlock; }
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   350
  static address cipherBlockChaining_encryptAESCrypt()  { return _cipherBlockChaining_encryptAESCrypt; }
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   351
  static address cipherBlockChaining_decryptAESCrypt()  { return _cipherBlockChaining_decryptAESCrypt; }
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   352
  static address counterMode_AESCrypt()  { return _counterMode_AESCrypt; }
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   353
  static address ghash_processBlocks()   { return _ghash_processBlocks; }
14132
3c1437abcefd 7184394: add intrinsics to use AES instructions
kvn
parents: 13728
diff changeset
   354
24953
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   355
  static address sha1_implCompress()     { return _sha1_implCompress; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   356
  static address sha1_implCompressMB()   { return _sha1_implCompressMB; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   357
  static address sha256_implCompress()   { return _sha256_implCompress; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   358
  static address sha256_implCompressMB() { return _sha256_implCompressMB; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   359
  static address sha512_implCompress()   { return _sha512_implCompress; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   360
  static address sha512_implCompressMB() { return _sha512_implCompressMB; }
9680119572be 8035968: Leverage CPU Instructions to Improve SHA Performance on SPARC
kvn
parents: 22823
diff changeset
   361
18507
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   362
  static address updateBytesCRC32()    { return _updateBytesCRC32; }
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   363
  static address crc_table_addr()      { return _crc_table_adr; }
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18025
diff changeset
   364
33066
d98eab8215c4 8134553: CRC32C implementations for x86/x64 targets
kvn
parents: 32581
diff changeset
   365
  static address crc32c_table_addr()   { return _crc32c_table_addr; }
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31404
diff changeset
   366
  static address updateBytesCRC32C()   { return _updateBytesCRC32C; }
32581
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 31584
diff changeset
   367
  static address updateBytesAdler32()  { return _updateBytesAdler32; }
31515
6aed85dadbe6 8073583: C2 support for CRC32C on SPARC
kvn
parents: 31404
diff changeset
   368
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   369
  static address multiplyToLen()       { return _multiplyToLen; }
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   370
  static address squareToLen()         { return _squareToLen; }
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   371
  static address mulAdd()              { return _mulAdd; }
31583
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   372
  static address montgomeryMultiply()  { return _montgomeryMultiply; }
eb5bea7b4835 8130150: Implement BigInteger.montgomeryMultiply intrinsic
aph
parents: 31129
diff changeset
   373
  static address montgomerySquare()    { return _montgomerySquare; }
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 25715
diff changeset
   374
35110
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   375
  static address vectorizedMismatch()  { return _vectorizedMismatch; }
f19bcdf40799 8143355: Update for addition of vectorizedMismatch intrinsic for x86
kvn
parents: 33485
diff changeset
   376
33465
6063f28a6efb 8139575: Update for x86 log in the math lib
iveresov
parents: 33089
diff changeset
   377
  static address dexp()                { return _dexp; }
6063f28a6efb 8139575: Update for x86 log in the math lib
iveresov
parents: 33089
diff changeset
   378
  static address dlog()                { return _dlog; }
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   379
  static address dlog10()              { return _dlog10; }
35146
9ebfec283f56 8145688: Update for x86 pow in the math lib
kvn
parents: 35135
diff changeset
   380
  static address dpow()                { return _dpow; }
35540
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   381
  static address dsin()                { return _dsin; }
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   382
  static address dcos()                { return _dcos; }
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   383
  static address dlibm_reduce_pi04l()  { return _dlibm_reduce_pi04l; }
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35154
diff changeset
   384
  static address dlibm_sin_cos_huge()  { return _dlibm_sin_cos_huge; }
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 35540
diff changeset
   385
  static address dlibm_tan_cot_huge()  { return _dlibm_tan_cot_huge; }
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 35540
diff changeset
   386
  static address dtan()                { return _dtan; }
33089
f4e956ed8b43 8132207: update for x86 exp in the math lib
iveresov
parents: 33066
diff changeset
   387
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   388
  static address select_fill_function(BasicType t, bool aligned, const char* &name);
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   389
46597
d669fb842ae3 8164888: Intrinsify fused mac operations on SPARC
neliasso
parents: 40010
diff changeset
   390
  static address zero_aligned_words()  { return _zero_aligned_words; }
6433
b0e4fafdc38b 4809552: Optimize Arrays.fill(...)
never
parents: 5547
diff changeset
   391
4645
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   392
  static double  intrinsic_log10(double d) {
33485
29d1dfa9bb4a 8140604: Internal Error runtime/stubRoutines.hpp:392 assert(_intrinsic_log != 0L) failed: must be defined
iveresov
parents: 33465
diff changeset
   393
    assert(_intrinsic_log10 != NULL, "must be defined");
4645
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   394
    return _intrinsic_log10(d);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   395
  }
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   396
  static double  intrinsic_pow(double d, double d2) {
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   397
    assert(_intrinsic_pow != NULL, "must be defined");
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   398
    return _intrinsic_pow(d, d2);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   399
  }
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   400
  static double  intrinsic_sin(double d) {
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   401
    assert(_intrinsic_sin != NULL, "must be defined");
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   402
    return _intrinsic_sin(d);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   403
  }
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   404
  static double  intrinsic_cos(double d) {
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   405
    assert(_intrinsic_cos != NULL, "must be defined");
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   406
    return _intrinsic_cos(d);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   407
  }
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   408
  static double  intrinsic_tan(double d) {
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   409
    assert(_intrinsic_tan != NULL, "must be defined");
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   410
    return _intrinsic_tan(d);
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   411
  }
0c5f5b94e93a 6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents: 189
diff changeset
   412
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  //
18740
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   414
  // Safefetch stub support
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   415
  //
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   416
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   417
  typedef int      (*SafeFetch32Stub)(int*      adr, int      errValue);
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   418
  typedef intptr_t (*SafeFetchNStub) (intptr_t* adr, intptr_t errValue);
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   419
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   420
  static SafeFetch32Stub SafeFetch32_stub() { return CAST_TO_FN_PTR(SafeFetch32Stub, _safefetch32_entry); }
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   421
  static SafeFetchNStub  SafeFetchN_stub()  { return CAST_TO_FN_PTR(SafeFetchNStub,  _safefetchN_entry); }
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   422
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   423
  static bool is_safefetch_fault(address pc) {
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   424
    return pc != NULL &&
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   425
          (pc == _safefetch32_fault_pc ||
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   426
           pc == _safefetchN_fault_pc);
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   427
  }
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   428
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   429
  static address continuation_for_safefetch_fault(address pc) {
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   430
    assert(_safefetch32_continuation_pc != NULL &&
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   431
           _safefetchN_continuation_pc  != NULL,
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   432
           "not initialized");
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   433
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   434
    if (pc == _safefetch32_fault_pc) return _safefetch32_continuation_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   435
    if (pc == _safefetchN_fault_pc)  return _safefetchN_continuation_pc;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   436
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   437
    ShouldNotReachHere();
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   438
    return NULL;
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   439
  }
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   440
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   441
  //
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  // Default versions of the above arraycopy functions for platforms which do
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // not have specialized versions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  //
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   445
  static void jbyte_copy     (jbyte*  src, jbyte*  dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   446
  static void jshort_copy    (jshort* src, jshort* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   447
  static void jint_copy      (jint*   src, jint*   dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   448
  static void jlong_copy     (jlong*  src, jlong*  dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   449
  static void oop_copy       (oop*    src, oop*    dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   450
  static void oop_copy_uninit(oop*    src, oop*    dest, size_t count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
8498
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   452
  static void arrayof_jbyte_copy     (HeapWord* src, HeapWord* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   453
  static void arrayof_jshort_copy    (HeapWord* src, HeapWord* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   454
  static void arrayof_jint_copy      (HeapWord* src, HeapWord* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   455
  static void arrayof_jlong_copy     (HeapWord* src, HeapWord* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   456
  static void arrayof_oop_copy       (HeapWord* src, HeapWord* dest, size_t count);
6398004126b9 6627983: G1: Bad oop deference during marking
iveresov
parents: 8107
diff changeset
   457
  static void arrayof_oop_copy_uninit(HeapWord* src, HeapWord* dest, size_t count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
   459
18740
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   460
// Safefetch allows to load a value from a location that's not known
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   461
// to be valid. If the load causes a fault, the error value is returned.
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   462
inline int SafeFetch32(int* adr, int errValue) {
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   463
  assert(StubRoutines::SafeFetch32_stub(), "stub not yet generated");
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   464
  return StubRoutines::SafeFetch32_stub()(adr, errValue);
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   465
}
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   466
inline intptr_t SafeFetchN(intptr_t* adr, intptr_t errValue) {
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   467
  assert(StubRoutines::SafeFetchN_stub(), "stub not yet generated");
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   468
  return StubRoutines::SafeFetchN_stub()(adr, errValue);
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   469
}
db44b1599483 8016697: Use stubs to implement safefetch
goetz
parents: 18507
diff changeset
   470
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 29181
diff changeset
   471
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 29181
diff changeset
   472
// returns true if SafeFetch32 and SafeFetchN can be used safely (stubroutines are already generated)
30118
dadad0daaab4 8075967: Zero interpreter asserts for SafeFetch<32,N> calls in ObjectMonitor
coleenp
parents: 29575
diff changeset
   473
inline bool CanUseSafeFetch32() {
30129
351788433103 8076185: Provide SafeFetchX implementation for zero
dholmes
parents: 30118
diff changeset
   474
  return StubRoutines::SafeFetch32_stub() ? true : false;
30118
dadad0daaab4 8075967: Zero interpreter asserts for SafeFetch<32,N> calls in ObjectMonitor
coleenp
parents: 29575
diff changeset
   475
}
29573
2d800e5d575f 8074552: SafeFetch32 and SafeFetchN do not work in error handling
dholmes
parents: 29181
diff changeset
   476
30129
351788433103 8076185: Provide SafeFetchX implementation for zero
dholmes
parents: 30118
diff changeset
   477
inline bool CanUseSafeFetchN() {
351788433103 8076185: Provide SafeFetchX implementation for zero
dholmes
parents: 30118
diff changeset
   478
  return StubRoutines::SafeFetchN_stub() ? true : false;
30118
dadad0daaab4 8075967: Zero interpreter asserts for SafeFetch<32,N> calls in ObjectMonitor
coleenp
parents: 29575
diff changeset
   479
}
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6433
diff changeset
   480
#endif // SHARE_VM_RUNTIME_STUBROUTINES_HPP