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

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)

author	mhorie
	Tue, 11 Dec 2018 20:31:18 -0500
changeset 52979	7384e00d5860
parent 52925	9c18c9d839d3
child 52992	4bb6e0871bf7
permissions	-rw-r--r--