src/hotspot/share/opto/classes.hpp
author mhorie
Tue, 11 Dec 2018 20:31:18 -0500
changeset 52979 7384e00d5860
parent 52925 9c18c9d839d3
child 52992 4bb6e0871bf7
permissions -rw-r--r--
8213754: PPC64: Add Intrinsics for isDigit/isLowerCase/isUpperCase/isWhitespace Reviewed-by: kvn, rriggs, mdoerr, gromero
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
52925
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
     2
 * Copyright (c) 1997, 2018, 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: 5352
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5352
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: 5352
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
50525
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
    25
#include "utilities/macros.hpp"
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
    26
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
// The giant table of Node classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// One entry per class, sorted by class name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
macro(AbsD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
macro(AbsF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
macro(AbsI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
macro(AddD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
macro(AddF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
macro(AddI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
macro(AddL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
macro(AddP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
macro(Allocate)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
macro(AllocateArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
macro(AndI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
macro(AndL)
26166
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 23491
diff changeset
    42
macro(ArrayCopy)
595
a2be4c89de81 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 590
diff changeset
    43
macro(AryEq)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
macro(AtanD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
macro(Binary)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
macro(Bool)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
macro(BoxLock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
macro(ReverseBytesI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
macro(ReverseBytesL)
5352
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 2862
diff changeset
    50
macro(ReverseBytesUS)
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 2862
diff changeset
    51
macro(ReverseBytesS)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
macro(CProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
macro(CallDynamicJava)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
macro(CallJava)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
macro(CallLeaf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
macro(CallLeafNoFP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
macro(CallRuntime)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
macro(CallStaticJava)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
macro(CastII)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
macro(CastX2P)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
macro(CastP2X)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
macro(CastPP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
macro(Catch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
macro(CatchProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
macro(CheckCastPP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
macro(ClearArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
macro(ConstraintCast)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
macro(CMoveD)
33469
30f4811eded0 8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents: 33465
diff changeset
    69
macro(CMoveVD)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
macro(CMoveF)
48309
1a0499fd252e 8192846: Support cmov vectorization for float
kvn
parents: 48145
diff changeset
    71
macro(CMoveVF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
macro(CMoveI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
macro(CMoveL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
macro(CMoveP)
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 392
diff changeset
    75
macro(CMoveN)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
    76
macro(CmpN)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
macro(CmpD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
macro(CmpD3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
macro(CmpF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
macro(CmpF3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
macro(CmpI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
macro(CmpL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
macro(CmpL3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
macro(CmpLTMask)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
macro(CmpP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
macro(CmpU)
45965
e29c1363af9a 8173770: Image conversion improvements
thartmann
parents: 41323
diff changeset
    87
macro(CmpUL)
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
    88
macro(CompareAndSwapB)
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
    89
macro(CompareAndSwapS)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
macro(CompareAndSwapI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
macro(CompareAndSwapL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
macro(CompareAndSwapP)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
    93
macro(CompareAndSwapN)
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
    94
macro(WeakCompareAndSwapB)
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
    95
macro(WeakCompareAndSwapS)
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
    96
macro(WeakCompareAndSwapI)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
    97
macro(WeakCompareAndSwapL)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
    98
macro(WeakCompareAndSwapP)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
    99
macro(WeakCompareAndSwapN)
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   100
macro(CompareAndExchangeB)
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   101
macro(CompareAndExchangeS)
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
   102
macro(CompareAndExchangeI)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
   103
macro(CompareAndExchangeL)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
   104
macro(CompareAndExchangeP)
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35540
diff changeset
   105
macro(CompareAndExchangeN)
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   106
macro(GetAndAddB)
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   107
macro(GetAndAddS)
13886
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   108
macro(GetAndAddI)
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   109
macro(GetAndAddL)
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   110
macro(GetAndSetB)
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38049
diff changeset
   111
macro(GetAndSetS)
13886
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   112
macro(GetAndSetI)
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   113
macro(GetAndSetL)
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   114
macro(GetAndSetP)
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13485
diff changeset
   115
macro(GetAndSetN)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
macro(Con)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
   117
macro(ConN)
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13930
diff changeset
   118
macro(ConNKlass)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
macro(ConD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
macro(ConF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
macro(ConI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
macro(ConL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
macro(ConP)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
macro(Conv2B)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
macro(ConvD2F)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
macro(ConvD2I)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
macro(ConvD2L)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
macro(ConvF2D)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
macro(ConvF2I)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
macro(ConvF2L)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
macro(ConvI2D)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
macro(ConvI2F)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
macro(ConvI2L)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
macro(ConvL2D)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
macro(ConvL2F)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
macro(ConvL2I)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
macro(CountedLoop)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
macro(CountedLoopEnd)
48145
f913f6dba2d3 8186027: C2: loop strip mining
roland
parents: 48089
diff changeset
   139
macro(OuterStripMinedLoop)
f913f6dba2d3 8186027: C2: loop strip mining
roland
parents: 48089
diff changeset
   140
macro(OuterStripMinedLoopEnd)
2862
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2348
diff changeset
   141
macro(CountLeadingZerosI)
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2348
diff changeset
   142
macro(CountLeadingZerosL)
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2348
diff changeset
   143
macro(CountTrailingZerosI)
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2348
diff changeset
   144
macro(CountTrailingZerosL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
macro(CreateEx)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
   146
macro(DecodeN)
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13930
diff changeset
   147
macro(DecodeNKlass)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
macro(DivD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
macro(DivF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
macro(DivI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
macro(DivL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
macro(DivMod)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
macro(DivModI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
macro(DivModL)
15242
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 13970
diff changeset
   155
macro(EncodeISOArray)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
   156
macro(EncodeP)
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13930
diff changeset
   157
macro(EncodePKlass)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
macro(FastLock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
macro(FastUnlock)
41323
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 39419
diff changeset
   160
macro(FmaD)
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 39419
diff changeset
   161
macro(FmaF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
macro(Goto)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
macro(Halt)
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33469
diff changeset
   164
macro(HasNegatives)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
macro(If)
34164
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33628
diff changeset
   166
macro(RangeCheck)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
macro(IfFalse)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
macro(IfTrue)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
macro(Initialize)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
macro(JProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
macro(Jump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
macro(JumpProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
macro(LShiftI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
macro(LShiftL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
macro(LoadB)
2150
0d91d17158cc 6797305: Add LoadUB and LoadUI opcode class
twisti
parents: 2022
diff changeset
   176
macro(LoadUB)
2022
28ce8115a91d 6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents: 1500
diff changeset
   177
macro(LoadUS)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
macro(LoadD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
macro(LoadD_unaligned)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
macro(LoadF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
macro(LoadI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
macro(LoadKlass)
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 392
diff changeset
   183
macro(LoadNKlass)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
macro(LoadL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
macro(LoadL_unaligned)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
macro(LoadPLocked)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
macro(LoadP)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
   188
macro(LoadN)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
macro(LoadRange)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
macro(LoadS)
50525
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   191
#if INCLUDE_ZGC
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   192
#define zgcmacro(x) macro(x)
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   193
#else
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   194
#define zgcmacro(x) optionalmacro(x)
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   195
#endif
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   196
zgcmacro(LoadBarrier)
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   197
zgcmacro(LoadBarrierSlowReg)
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 49384
diff changeset
   198
zgcmacro(LoadBarrierWeakSlowReg)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
macro(Lock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
macro(Loop)
9446
748a37b25d10 5091921: Sign flip issues in loop optimizer
kvn
parents: 5547
diff changeset
   201
macro(LoopLimit)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
macro(Mach)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
macro(MachProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
macro(MaxI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
macro(MemBarAcquire)
22855
d637fd28a6c3 8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents: 21105
diff changeset
   206
macro(LoadFence)
38049
e8541793960f 8153998: Masked vector post loops
mcberg
parents: 38018
diff changeset
   207
macro(SetVectMaskI)
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 9446
diff changeset
   208
macro(MemBarAcquireLock)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
macro(MemBarCPUOrder)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
macro(MemBarRelease)
22855
d637fd28a6c3 8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents: 21105
diff changeset
   211
macro(StoreFence)
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 9446
diff changeset
   212
macro(MemBarReleaseLock)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
macro(MemBarVolatile)
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 10267
diff changeset
   214
macro(MemBarStoreStore)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
macro(MergeMem)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
macro(MinI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
macro(ModD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
macro(ModF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
macro(ModI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
macro(ModL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
macro(MoveI2F)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
macro(MoveF2I)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
macro(MoveL2D)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
macro(MoveD2L)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
macro(MulD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
macro(MulF)
392
0b3167e2f2de 6603011: RFE: Optimize long division
rasbold
parents: 360
diff changeset
   227
macro(MulHiL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
macro(MulI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
macro(MulL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
macro(Multi)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
macro(NegD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
macro(NegF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
macro(NeverBranch)
38017
55047d16f141 8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents: 36316
diff changeset
   234
macro(OnSpinWait)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
macro(Opaque1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
macro(Opaque2)
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22911
diff changeset
   237
macro(Opaque3)
46525
3a5c833a43de 8176506: C2: loop unswitching and unsafe accesses cause crash
roland
parents: 41323
diff changeset
   238
macro(Opaque4)
28912
27fac2f8fdbe 8063137: Never-taken branches should be pruned when GWT LambdaForms are shared
vlivanov
parents: 26166
diff changeset
   239
macro(ProfileBoolean)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
macro(OrI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
macro(OrL)
22911
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   242
macro(OverflowAddI)
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   243
macro(OverflowSubI)
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   244
macro(OverflowMulI)
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   245
macro(OverflowAddL)
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   246
macro(OverflowSubL)
ff49c48c887d 8027754: Enable loop optimizations for loops with MathExact inside
rbackman
parents: 22872
diff changeset
   247
macro(OverflowMulL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
macro(PCTable)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
macro(Parm)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
macro(PartialSubtypeCheck)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
macro(Phi)
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 2150
diff changeset
   252
macro(PopCountI)
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 2150
diff changeset
   253
macro(PopCountL)
49384
b242a1e3f9cf 8199421: Add support for vector popcount
rlupusoru
parents: 48309
diff changeset
   254
macro(PopCountVI)
10267
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
   255
macro(PrefetchAllocation)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
macro(Proj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
macro(RShiftI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
macro(RShiftL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
macro(Region)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
macro(Rethrow)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
macro(Return)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
macro(Root)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
macro(RoundDouble)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
macro(RoundFloat)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
macro(SafePoint)
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
   266
macro(SafePointScalarObject)
52925
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   267
#if INCLUDE_SHENANDOAHGC
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   268
#define shmacro(x) macro(x)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   269
#else
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   270
#define shmacro(x) optionalmacro(x)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   271
#endif
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   272
shmacro(ShenandoahCompareAndExchangeP)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   273
shmacro(ShenandoahCompareAndExchangeN)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   274
shmacro(ShenandoahCompareAndSwapN)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   275
shmacro(ShenandoahCompareAndSwapP)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   276
shmacro(ShenandoahWeakCompareAndSwapN)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   277
shmacro(ShenandoahWeakCompareAndSwapP)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   278
shmacro(ShenandoahEnqueueBarrier)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   279
shmacro(ShenandoahReadBarrier)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   280
shmacro(ShenandoahWriteBarrier)
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 50525
diff changeset
   281
shmacro(ShenandoahWBMemProj)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
macro(SCMemProj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
macro(SqrtD)
48089
22c9856fc2c2 8190800: Support vectorization of Math.sqrt() on floats
rlupusoru
parents: 47216
diff changeset
   284
macro(SqrtF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
macro(Start)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
macro(StartOSR)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
macro(StoreB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
macro(StoreC)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
macro(StoreCM)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
macro(StorePConditional)
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 670
diff changeset
   291
macro(StoreIConditional)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
macro(StoreLConditional)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
macro(StoreD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
macro(StoreF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
macro(StoreI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
macro(StoreL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
macro(StoreP)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 236
diff changeset
   298
macro(StoreN)
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13930
diff changeset
   299
macro(StoreNKlass)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
macro(StrComp)
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33469
diff changeset
   301
macro(StrCompressedCopy)
2348
4e71ed4c2709 6761600: Use sse 4.2 in intrinsics
cfang
parents: 2259
diff changeset
   302
macro(StrEquals)
4e71ed4c2709 6761600: Use sse 4.2 in intrinsics
cfang
parents: 2259
diff changeset
   303
macro(StrIndexOf)
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33469
diff changeset
   304
macro(StrIndexOfChar)
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33469
diff changeset
   305
macro(StrInflatedCopy)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
macro(SubD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
macro(SubF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
macro(SubI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
macro(SubL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
macro(TailCall)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
macro(TailJump)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
macro(ThreadLocal)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
macro(Unlock)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
macro(URShiftI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
macro(URShiftL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
macro(XorI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
macro(XorL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
macro(Vector)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
macro(AddVB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
macro(AddVS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
macro(AddVI)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   322
macro(AddReductionVI)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
macro(AddVL)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   324
macro(AddReductionVL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
macro(AddVF)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   326
macro(AddReductionVF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
macro(AddVD)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   328
macro(AddReductionVD)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
macro(SubVB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
macro(SubVS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
macro(SubVI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
macro(SubVL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
macro(SubVF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
macro(SubVD)
13485
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   335
macro(MulVS)
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   336
macro(MulVI)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   337
macro(MulReductionVI)
30624
2e1803c8a26d 8076276: Add support for AVX512
kvn
parents: 30211
diff changeset
   338
macro(MulVL)
2e1803c8a26d 8076276: Add support for AVX512
kvn
parents: 30211
diff changeset
   339
macro(MulReductionVL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
macro(MulVF)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   341
macro(MulReductionVF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
macro(MulVD)
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 28957
diff changeset
   343
macro(MulReductionVD)
46528
cf0da758e7b5 8181616: FMA Vectorization on x86
vdeshpande
parents: 46525
diff changeset
   344
macro(FmaVD)
cf0da758e7b5 8181616: FMA Vectorization on x86
vdeshpande
parents: 46525
diff changeset
   345
macro(FmaVF)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
macro(DivVF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
macro(DivVD)
33088
34fe49ecee13 8138583: aarch64: add support for vectorizing fabs/fneg
enevill
parents: 32723
diff changeset
   348
macro(AbsVF)
34fe49ecee13 8138583: aarch64: add support for vectorizing fabs/fneg
enevill
parents: 32723
diff changeset
   349
macro(AbsVD)
34fe49ecee13 8138583: aarch64: add support for vectorizing fabs/fneg
enevill
parents: 32723
diff changeset
   350
macro(NegVF)
34fe49ecee13 8138583: aarch64: add support for vectorizing fabs/fneg
enevill
parents: 32723
diff changeset
   351
macro(NegVD)
32723
56534fb3d71a 8135028: support for vectorizing double precision sqrt
mcberg
parents: 30624
diff changeset
   352
macro(SqrtVD)
48089
22c9856fc2c2 8190800: Support vectorization of Math.sqrt() on floats
rlupusoru
parents: 47216
diff changeset
   353
macro(SqrtVF)
13930
8df570f94294 7201026: add vector for shift count
kvn
parents: 13886
diff changeset
   354
macro(LShiftCntV)
8df570f94294 7201026: add vector for shift count
kvn
parents: 13886
diff changeset
   355
macro(RShiftCntV)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
macro(LShiftVB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
macro(LShiftVS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
macro(LShiftVI)
13485
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   359
macro(LShiftVL)
13104
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   360
macro(RShiftVB)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   361
macro(RShiftVS)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   362
macro(RShiftVI)
13485
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   363
macro(RShiftVL)
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   364
macro(URShiftVB)
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   365
macro(URShiftVS)
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   366
macro(URShiftVI)
6c7faa516fc6 6340864: Implement vectorization optimizations in hotspot-server
kvn
parents: 13104
diff changeset
   367
macro(URShiftVL)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
macro(AndV)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
macro(OrV)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
macro(XorV)
13104
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   371
macro(LoadVector)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   372
macro(StoreVector)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
macro(Pack)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
macro(PackB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
macro(PackS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
macro(PackI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
macro(PackL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
macro(PackF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
macro(PackD)
13104
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   380
macro(Pack2L)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   381
macro(Pack2D)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   382
macro(ReplicateB)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   383
macro(ReplicateS)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   384
macro(ReplicateI)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   385
macro(ReplicateL)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   386
macro(ReplicateF)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   387
macro(ReplicateD)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
macro(Extract)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
macro(ExtractB)
13104
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   390
macro(ExtractUB)
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
   391
macro(ExtractC)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
macro(ExtractS)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
macro(ExtractI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
macro(ExtractL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
macro(ExtractF)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
macro(ExtractD)
52979
7384e00d5860 8213754: PPC64: Add Intrinsics for isDigit/isLowerCase/isUpperCase/isWhitespace
mhorie
parents: 52925
diff changeset
   397
macro(Digit)
7384e00d5860 8213754: PPC64: Add Intrinsics for isDigit/isLowerCase/isUpperCase/isWhitespace
mhorie
parents: 52925
diff changeset
   398
macro(LowerCase)
7384e00d5860 8213754: PPC64: Add Intrinsics for isDigit/isLowerCase/isUpperCase/isWhitespace
mhorie
parents: 52925
diff changeset
   399
macro(UpperCase)
7384e00d5860 8213754: PPC64: Add Intrinsics for isDigit/isLowerCase/isUpperCase/isWhitespace
mhorie
parents: 52925
diff changeset
   400
macro(Whitespace)