hotspot/src/cpu/x86/vm/globals_x86.hpp
author kvn
Mon, 10 Jul 2017 14:28:40 -0700
changeset 45806 36707109c109
parent 45804 41b19cb98a96
child 45871 878e21603932
permissions -rw-r--r--
8184036: Restore -XX:UseAVX=3 as product value Reviewed-by: dlong, roland
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
35581
dd47cf4734f2 8145336: PPC64: fix string intrinsics after CompactStrings change
simonis
parents: 35540
diff changeset
     2
 * Copyright (c) 2000, 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: 5249
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5249
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: 5249
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: 6965
diff changeset
    25
#ifndef CPU_X86_VM_GLOBALS_X86_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    26
#define CPU_X86_VM_GLOBALS_X86_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    28
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    29
#include "utilities/macros.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    30
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// Sets the default values for platform dependent flags used by the runtime system.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// (see globals.hpp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    34
define_pd_global(bool, ShareVtableStubs,         true);
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    35
define_pd_global(bool, NeedsDeoptSuspend,        false); // only register window machines need this
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    37
define_pd_global(bool, ImplicitNullChecks,       true);  // Generate code for implicit null checks
22856
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 21095
diff changeset
    38
define_pd_global(bool, TrapBasedNullChecks,      false); // Not needed on x86.
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 21095
diff changeset
    39
define_pd_global(bool, UncommonNullCast,         true);  // Uncommon-trap NULLs passed to check cast
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
42062
473286891dd8 8166560: [s390] Basic enablement of s390 port.
goetz
parents: 40926
diff changeset
    41
define_pd_global(uintx, CodeCacheSegmentSize,    64 TIERED_ONLY(+64)); // Tiered compilation has large code-entry alignment.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// See 4827828 for this change. There is no globals_core_i486.hpp. I can't
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// assign a different value for C2 without touching a number of files. Use
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// #ifdef to minimize the change as it's late in Mantis. -- FIXME.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// c1 doesn't have this problem because the fix to 4858033 assures us
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// the the vep is aligned at CodeEntryAlignment whereas c2 only aligns
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// the uep and the vep doesn't get real alignment but just slops on by
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// only assured that the entry instruction meets the 5 byte size requirement.
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31783
diff changeset
    49
#if defined(COMPILER2) || INCLUDE_JVMCI
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    50
define_pd_global(intx, CodeEntryAlignment,       32);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
#else
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    52
define_pd_global(intx, CodeEntryAlignment,       16);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
#endif // COMPILER2
5249
5cac34e6fe54 6940701: Don't align loops in stubs for Niagara sparc
kvn
parents: 4434
diff changeset
    54
define_pd_global(intx, OptoLoopAlignment,        16);
4434
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    55
define_pd_global(intx, InlineFrequencyCount,     100);
4b41e5b42f81 6887571: Increase default heap config sizes
phh
parents: 3261
diff changeset
    56
define_pd_global(intx, InlineSmallCode,          1000);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    58
#define DEFAULT_STACK_YELLOW_PAGES (NOT_WINDOWS(2) WINDOWS_ONLY(3))
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    59
#define DEFAULT_STACK_RED_PAGES (1)
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33628
diff changeset
    60
#define DEFAULT_STACK_RESERVED_PAGES (NOT_WINDOWS(1) WINDOWS_ONLY(0))
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    61
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    62
#define MIN_STACK_YELLOW_PAGES DEFAULT_STACK_YELLOW_PAGES
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    63
#define MIN_STACK_RED_PAGES DEFAULT_STACK_RED_PAGES
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33628
diff changeset
    64
#define MIN_STACK_RESERVED_PAGES (0)
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    65
42906
1a8db9cf1407 8170655: [posix] Fix minimum stack size computations
goetz
parents: 42062
diff changeset
    66
#ifdef _LP64
1a8db9cf1407 8170655: [posix] Fix minimum stack size computations
goetz
parents: 42062
diff changeset
    67
// Java_java_net_SocketOutputStream_socketWrite0() uses a 64k buffer on the
1a8db9cf1407 8170655: [posix] Fix minimum stack size computations
goetz
parents: 42062
diff changeset
    68
// stack if compiled for unix and LP64. To pass stack overflow tests we need
1a8db9cf1407 8170655: [posix] Fix minimum stack size computations
goetz
parents: 42062
diff changeset
    69
// 20 shadow pages.
40926
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 38273
diff changeset
    70
#define DEFAULT_STACK_SHADOW_PAGES (NOT_WIN64(20) WIN64_ONLY(7) DEBUG_ONLY(+2))
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    71
// For those clients that do not use write socket, we allow
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    72
// the min range value to be below that of the default
40926
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 38273
diff changeset
    73
#define MIN_STACK_SHADOW_PAGES (NOT_WIN64(10) WIN64_ONLY(7) DEBUG_ONLY(+2))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
#else
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    75
#define DEFAULT_STACK_SHADOW_PAGES (4 DEBUG_ONLY(+5))
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    76
#define MIN_STACK_SHADOW_PAGES DEFAULT_STACK_SHADOW_PAGES
42906
1a8db9cf1407 8170655: [posix] Fix minimum stack size computations
goetz
parents: 42062
diff changeset
    77
#endif // _LP64
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    79
define_pd_global(intx, StackYellowPages, DEFAULT_STACK_YELLOW_PAGES);
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    80
define_pd_global(intx, StackRedPages, DEFAULT_STACK_RED_PAGES);
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    81
define_pd_global(intx, StackShadowPages, DEFAULT_STACK_SHADOW_PAGES);
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 33628
diff changeset
    82
define_pd_global(intx, StackReservedPages, DEFAULT_STACK_RESERVED_PAGES);
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
    83
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
define_pd_global(bool, RewriteBytecodes,     true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
define_pd_global(bool, RewriteFrequentPairs, true);
6965
4ef36b2a6a3a 6989297: Integrate additional portability improvements
bobv
parents: 5547
diff changeset
    86
10565
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 8687
diff changeset
    87
#ifdef _ALLBSD_SOURCE
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 8687
diff changeset
    88
define_pd_global(bool, UseMembar,            true);
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 8687
diff changeset
    89
#else
6965
4ef36b2a6a3a 6989297: Integrate additional portability improvements
bobv
parents: 5547
diff changeset
    90
define_pd_global(bool, UseMembar,            false);
10565
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 8687
diff changeset
    91
#endif
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
    92
8687
264727307495 6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents: 7921
diff changeset
    93
// GC Ergo Flags
29697
92501504191b 8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents: 28954
diff changeset
    94
define_pd_global(size_t, CMSYoungGenPerWorker, 64*M);  // default max size of CMS young gen, per GC worker thread
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
    95
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
    96
define_pd_global(uintx, TypeProfileLevel, 111);
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 18507
diff changeset
    97
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33230
diff changeset
    98
define_pd_global(bool, CompactStrings, true);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33230
diff changeset
    99
30305
b92a97e1e9cb 8068945: Use RBP register as proper frame pointer in JIT compiled code on x86
zmajo
parents: 29697
diff changeset
   100
define_pd_global(bool, PreserveFramePointer, false);
b92a97e1e9cb 8068945: Use RBP register as proper frame pointer in JIT compiled code on x86
zmajo
parents: 29697
diff changeset
   101
36554
a7eb9ee4680c 8146801: Allocating short arrays of non-constant size is slow
shade
parents: 36099
diff changeset
   102
define_pd_global(intx, InitArrayShortSize, 8*BytesPerLong);
a7eb9ee4680c 8146801: Allocating short arrays of non-constant size is slow
shade
parents: 36099
diff changeset
   103
38273
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   104
#define ARCH_FLAGS(develop, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   105
                   product, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   106
                   diagnostic, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   107
                   experimental, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   108
                   notproduct, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   109
                   range, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   110
                   constraint, \
2634194d7555 8073500: Prevent certain commercial flags from being changed at runtime
gziemski
parents: 38018
diff changeset
   111
                   writeable) \
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   112
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   113
  develop(bool, IEEEPrecision, true,                                        \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   114
          "Enables IEEE precision (for INTEL only)")                        \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   115
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   116
  product(bool, UseStoreImmI16, true,                                       \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   117
          "Use store immediate 16-bits value instruction on x86")           \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   118
                                                                            \
45804
41b19cb98a96 8183103: Post loop vectorization produces incorrect results
thartmann
parents: 42906
diff changeset
   119
  product(intx, UseAVX, 2,                                                  \
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   120
          "Highest supported AVX instructions set on x86/x64")              \
33163
9e128b399e48 8078554: Compiler: implement ranges (optionally constraints) for those flags that have them missing
zmajo
parents: 33160
diff changeset
   121
          range(0, 99)                                                      \
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   122
                                                                            \
18507
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18088
diff changeset
   123
  product(bool, UseCLMUL, false,                                            \
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18088
diff changeset
   124
          "Control whether CLMUL instructions can be used on x86/x64")      \
61bfc8995bb3 7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents: 18088
diff changeset
   125
                                                                            \
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   126
  diagnostic(bool, UseIncDec, true,                                         \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   127
          "Use INC, DEC instructions on x86")                               \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   128
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   129
  product(bool, UseNewLongLShift, false,                                    \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   130
          "Use optimized bitwise shift left")                               \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   131
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   132
  product(bool, UseAddressNop, false,                                       \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   133
          "Use '0F 1F [addr]' NOP instructions on x86 cpus")                \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   134
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   135
  product(bool, UseXmmLoadAndClearUpper, true,                              \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   136
          "Load low part of XMM register and clear upper part")             \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   137
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   138
  product(bool, UseXmmRegToRegMoveAll, false,                               \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   139
          "Copy all XMM register bits when moving value between registers") \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   140
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   141
  product(bool, UseXmmI2D, false,                                           \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   142
          "Use SSE2 CVTDQ2PD instruction to convert Integer to Double")     \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   143
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   144
  product(bool, UseXmmI2F, false,                                           \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   145
          "Use SSE2 CVTDQ2PS instruction to convert Integer to Float")      \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   146
                                                                            \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   147
  product(bool, UseUnalignedLoadStores, false,                              \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   148
          "Use SSE2 MOVDQU instruction for Arraycopy")                      \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   149
                                                                            \
15114
4074553c678b 8005522: use fast-string instructions on x86 for zeroing
kvn
parents: 13521
diff changeset
   150
  product(bool, UseFastStosb, false,                                        \
4074553c678b 8005522: use fast-string instructions on x86 for zeroing
kvn
parents: 13521
diff changeset
   151
          "Use fast-string operation for zeroing: rep stosb")               \
4074553c678b 8005522: use fast-string instructions on x86 for zeroing
kvn
parents: 13521
diff changeset
   152
                                                                            \
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   153
  /* Use Restricted Transactional Memory for lock eliding */                \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   154
  product(bool, UseRTMLocking, false,                                       \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   155
          "Enable RTM lock eliding for inflated locks in compiled code")    \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   156
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   157
  experimental(bool, UseRTMForStackLocks, false,                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   158
          "Enable RTM lock eliding for stack locks in compiled code")       \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   159
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   160
  product(bool, UseRTMDeopt, false,                                         \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   161
          "Perform deopt and recompilation based on RTM abort ratio")       \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   162
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   163
  product(uintx, RTMRetryCount, 5,                                          \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   164
          "Number of RTM retries on lock abort or busy")                    \
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 31783
diff changeset
   165
          range(0, max_uintx)                                               \
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   166
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   167
  experimental(intx, RTMSpinLoopCount, 100,                                 \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   168
          "Spin count for lock to become free before RTM retry")            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   169
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   170
  experimental(intx, RTMAbortThreshold, 1000,                               \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   171
          "Calculate abort ratio after this number of aborts")              \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   172
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   173
  experimental(intx, RTMLockingThreshold, 10000,                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   174
          "Lock count at which to do RTM lock eliding without "             \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   175
          "abort ratio calculation")                                        \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   176
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   177
  experimental(intx, RTMAbortRatio, 50,                                     \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   178
          "Lock abort ratio at which to stop use RTM lock eliding")         \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   179
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   180
  experimental(intx, RTMTotalCountIncrRate, 64,                             \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   181
          "Increment total RTM attempted lock count once every n times")    \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   182
                                                                            \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   183
  experimental(intx, RTMLockingCalculationDelay, 0,                         \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   184
          "Number of milliseconds to wait before start calculating aborts " \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   185
          "for RTM locking")                                                \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   186
                                                                            \
23847
d792e42aeb4f 8038939: Some options related to RTM locking optimization works inconsistently
kvn
parents: 23491
diff changeset
   187
  experimental(bool, UseRTMXendForLockBusy, true,                           \
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   188
          "Use RTM Xend instead of Xabort when lock busy")                  \
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23220
diff changeset
   189
                                                                            \
13521
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   190
  /* assembler */                                                           \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   191
  product(bool, UseCountLeadingZerosInstruction, false,                     \
97a23be06f4e 6677625: Move platform specific flags from globals.hpp to globals_<arch>.hpp
twisti
parents: 11796
diff changeset
   192
          "Use count leading zeros instruction")                            \
23220
fc827339dc37 8031321: Support Intel bit manipulation instructions
iveresov
parents: 22856
diff changeset
   193
                                                                            \
fc827339dc37 8031321: Support Intel bit manipulation instructions
iveresov
parents: 22856
diff changeset
   194
  product(bool, UseCountTrailingZerosInstruction, false,                    \
fc827339dc37 8031321: Support Intel bit manipulation instructions
iveresov
parents: 22856
diff changeset
   195
          "Use count trailing zeros instruction")                           \
fc827339dc37 8031321: Support Intel bit manipulation instructions
iveresov
parents: 22856
diff changeset
   196
                                                                            \
35581
dd47cf4734f2 8145336: PPC64: fix string intrinsics after CompactStrings change
simonis
parents: 35540
diff changeset
   197
  product(bool, UseSSE42Intrinsics, false,                                  \
dd47cf4734f2 8145336: PPC64: fix string intrinsics after CompactStrings change
simonis
parents: 35540
diff changeset
   198
          "SSE4.2 versions of intrinsics")                                  \
dd47cf4734f2 8145336: PPC64: fix string intrinsics after CompactStrings change
simonis
parents: 35540
diff changeset
   199
                                                                            \
23220
fc827339dc37 8031321: Support Intel bit manipulation instructions
iveresov
parents: 22856
diff changeset
   200
  product(bool, UseBMI1Instructions, false,                                 \
26434
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 23847
diff changeset
   201
          "Use BMI1 instructions")                                          \
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 23847
diff changeset
   202
                                                                            \
09ad55e5f486 8055494: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
kvn
parents: 23847
diff changeset
   203
  product(bool, UseBMI2Instructions, false,                                 \
35540
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35135
diff changeset
   204
          "Use BMI2 instructions")                                          \
e001ad24dcdb 8143353: update for x86 sin and cos in the math lib
vdeshpande
parents: 35135
diff changeset
   205
                                                                            \
38018
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 36554
diff changeset
   206
  diagnostic(bool, UseLibmIntrinsic, true,                                  \
1dc6c6f21231 8152907: Update for x86 tan and log10 in the math lib
vdeshpande
parents: 36554
diff changeset
   207
          "Use Libm Intrinsics")
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6965
diff changeset
   208
#endif // CPU_X86_VM_GLOBALS_X86_HPP