jdk-sandbox: src/hotspot/share/opto/classes.hpp@6fc57e391539 (annotated)

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

author	neliasso
	Tue, 01 Oct 2019 11:43:10 +0200
changeset 58421	6fc57e391539
parent 58019	86b95fc6ca32
child 58516	d376d86b0a01
permissions	-rw-r--r--