author | shade |
Wed, 15 Jun 2016 11:21:36 +0300 | |
changeset 39419 | cc993a4ab581 |
parent 38017 | 55047d16f141 |
child 44739 | 3af2c3740d7b |
permissions | -rw-r--r-- |
1 | 1 |
/* |
28954
7dda6c26cc98
8068977: Remove unused sun.misc.Unsafe prefetch intrinsic support
psandoz
parents:
27697
diff
changeset
|
2 |
* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5251
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5251
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:
5251
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_OPTO_MEMNODE_HPP |
26 |
#define SHARE_VM_OPTO_MEMNODE_HPP |
|
27 |
||
28 |
#include "opto/multnode.hpp" |
|
29 |
#include "opto/node.hpp" |
|
30 |
#include "opto/opcodes.hpp" |
|
31 |
#include "opto/type.hpp" |
|
32 |
||
1 | 33 |
// Portions of code courtesy of Clifford Click |
34 |
||
35 |
class MultiNode; |
|
36 |
class PhaseCCP; |
|
37 |
class PhaseTransform; |
|
38 |
||
39 |
//------------------------------MemNode---------------------------------------- |
|
40 |
// Load or Store, possibly throwing a NULL pointer exception |
|
41 |
class MemNode : public Node { |
|
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
42 |
private: |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
43 |
bool _unaligned_access; // Unaligned access from unsafe |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
44 |
bool _mismatched_access; // Mismatched access from unsafe: byte read in integer array for instance |
1 | 45 |
protected: |
46 |
#ifdef ASSERT |
|
47 |
const TypePtr* _adr_type; // What kind of memory is being addressed? |
|
48 |
#endif |
|
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
49 |
virtual uint size_of() const; |
1 | 50 |
public: |
51 |
enum { Control, // When is it safe to do this load? |
|
52 |
Memory, // Chunk of memory is being loaded from |
|
53 |
Address, // Actually address, derived from base |
|
54 |
ValueIn, // Value to store |
|
55 |
OopStore // Preceeding oop store, only in StoreCM |
|
56 |
}; |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
57 |
typedef enum { unordered = 0, |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
58 |
acquire, // Load has to acquire or be succeeded by MemBarAcquire. |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
59 |
release, // Store has to release or be preceded by MemBarRelease. |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
60 |
seqcst, // LoadStore has to have both acquire and release semantics. |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
61 |
unset // The memory ordering is not set (used for testing) |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
62 |
} MemOrd; |
1 | 63 |
protected: |
64 |
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at ) |
|
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
65 |
: Node(c0,c1,c2 ), _unaligned_access(false), _mismatched_access(false) { |
1 | 66 |
init_class_id(Class_Mem); |
67 |
debug_only(_adr_type=at; adr_type();) |
|
68 |
} |
|
69 |
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3 ) |
|
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
70 |
: Node(c0,c1,c2,c3), _unaligned_access(false), _mismatched_access(false) { |
1 | 71 |
init_class_id(Class_Mem); |
72 |
debug_only(_adr_type=at; adr_type();) |
|
73 |
} |
|
74 |
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3, Node *c4) |
|
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
75 |
: Node(c0,c1,c2,c3,c4), _unaligned_access(false), _mismatched_access(false) { |
1 | 76 |
init_class_id(Class_Mem); |
77 |
debug_only(_adr_type=at; adr_type();) |
|
78 |
} |
|
79 |
||
30629
b6e5ad2f18d5
8076188: Optimize arraycopy out for non escaping destination
roland
parents:
30300
diff
changeset
|
80 |
virtual Node* find_previous_arraycopy(PhaseTransform* phase, Node* ld_alloc, Node*& mem, bool can_see_stored_value) const { return NULL; } |
b6e5ad2f18d5
8076188: Optimize arraycopy out for non escaping destination
roland
parents:
30300
diff
changeset
|
81 |
|
206 | 82 |
public: |
1 | 83 |
// Helpers for the optimizer. Documented in memnode.cpp. |
84 |
static bool detect_ptr_independence(Node* p1, AllocateNode* a1, |
|
85 |
Node* p2, AllocateNode* a2, |
|
86 |
PhaseTransform* phase); |
|
87 |
static bool adr_phi_is_loop_invariant(Node* adr_phi, Node* cast); |
|
88 |
||
17383 | 89 |
static Node *optimize_simple_memory_chain(Node *mchain, const TypeOopPtr *t_oop, Node *load, PhaseGVN *phase); |
90 |
static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, Node *load, PhaseGVN *phase); |
|
1 | 91 |
// This one should probably be a phase-specific function: |
258
dbd6f2ed7ba0
6692301: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents:
247
diff
changeset
|
92 |
static bool all_controls_dominate(Node* dom, Node* sub); |
1 | 93 |
|
94 |
virtual const class TypePtr *adr_type() const; // returns bottom_type of address |
|
95 |
||
96 |
// Shared code for Ideal methods: |
|
97 |
Node *Ideal_common(PhaseGVN *phase, bool can_reshape); // Return -1 for short-circuit NULL. |
|
98 |
||
99 |
// Helper function for adr_type() implementations. |
|
100 |
static const TypePtr* calculate_adr_type(const Type* t, const TypePtr* cross_check = NULL); |
|
101 |
||
102 |
// Raw access function, to allow copying of adr_type efficiently in |
|
103 |
// product builds and retain the debug info for debug builds. |
|
104 |
const TypePtr *raw_adr_type() const { |
|
105 |
#ifdef ASSERT |
|
106 |
return _adr_type; |
|
107 |
#else |
|
108 |
return 0; |
|
109 |
#endif |
|
110 |
} |
|
111 |
||
112 |
// Map a load or store opcode to its corresponding store opcode. |
|
113 |
// (Return -1 if unknown.) |
|
114 |
virtual int store_Opcode() const { return -1; } |
|
115 |
||
116 |
// What is the type of the value in memory? (T_VOID mean "unspecified".) |
|
117 |
virtual BasicType memory_type() const = 0; |
|
202
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
118 |
virtual int memory_size() const { |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
119 |
#ifdef ASSERT |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
120 |
return type2aelembytes(memory_type(), true); |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
121 |
#else |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
122 |
return type2aelembytes(memory_type()); |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
123 |
#endif |
dc13bf0e5d5d
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
190
diff
changeset
|
124 |
} |
1 | 125 |
|
126 |
// Search through memory states which precede this node (load or store). |
|
127 |
// Look for an exact match for the address, with no intervening |
|
128 |
// aliased stores. |
|
129 |
Node* find_previous_store(PhaseTransform* phase); |
|
130 |
||
131 |
// Can this node (load or store) accurately see a stored value in |
|
132 |
// the given memory state? (The state may or may not be in(Memory).) |
|
133 |
Node* can_see_stored_value(Node* st, PhaseTransform* phase) const; |
|
134 |
||
34157
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
135 |
void set_unaligned_access() { _unaligned_access = true; } |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
136 |
bool is_unaligned_access() const { return _unaligned_access; } |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
137 |
void set_mismatched_access() { _mismatched_access = true; } |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
138 |
bool is_mismatched_access() const { return _mismatched_access; } |
4fde32e81092
8140309: [REDO] failed: no mismatched stores, except on raw memory: StoreB StoreI
roland
parents:
33459
diff
changeset
|
139 |
|
1 | 140 |
#ifndef PRODUCT |
141 |
static void dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st); |
|
142 |
virtual void dump_spec(outputStream *st) const; |
|
143 |
#endif |
|
144 |
}; |
|
145 |
||
146 |
//------------------------------LoadNode--------------------------------------- |
|
147 |
// Load value; requires Memory and Address |
|
148 |
class LoadNode : public MemNode { |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
149 |
public: |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
150 |
// Some loads (from unsafe) should be pinned: they don't depend only |
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
151 |
// on the dominating test. The field _control_dependency below records |
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
152 |
// whether that node depends only on the dominating test. |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
153 |
// Methods used to build LoadNodes pass an argument of type enum |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
154 |
// ControlDependency instead of a boolean because those methods |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
155 |
// typically have multiple boolean parameters with default values: |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
156 |
// passing the wrong boolean to one of these parameters by mistake |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
157 |
// goes easily unnoticed. Using an enum, the compiler can check that |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
158 |
// the type of a value and the type of the parameter match. |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
159 |
enum ControlDependency { |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
160 |
Pinned, |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
161 |
DependsOnlyOnTest |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
162 |
}; |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
163 |
private: |
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
164 |
// LoadNode::hash() doesn't take the _control_dependency field |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
165 |
// into account: If the graph already has a non-pinned LoadNode and |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
166 |
// we add a pinned LoadNode with the same inputs, it's safe for GVN |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
167 |
// to replace the pinned LoadNode with the non-pinned LoadNode, |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
168 |
// otherwise it wouldn't be safe to have a non pinned LoadNode with |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
169 |
// those inputs in the first place. If the graph already has a |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
170 |
// pinned LoadNode and we add a non pinned LoadNode with the same |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
171 |
// inputs, it's safe (but suboptimal) for GVN to replace the |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
172 |
// non-pinned LoadNode by the pinned LoadNode. |
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
173 |
ControlDependency _control_dependency; |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
174 |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
175 |
// On platforms with weak memory ordering (e.g., PPC, Ia64) we distinguish |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
176 |
// loads that can be reordered, and such requiring acquire semantics to |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
177 |
// adhere to the Java specification. The required behaviour is stored in |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
178 |
// this field. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
179 |
const MemOrd _mo; |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
180 |
|
1 | 181 |
protected: |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
182 |
virtual uint cmp(const Node &n) const; |
1 | 183 |
virtual uint size_of() const; // Size is bigger |
27637
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
184 |
// Should LoadNode::Ideal() attempt to remove control edges? |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
185 |
virtual bool can_remove_control() const; |
1 | 186 |
const Type* const _type; // What kind of value is loaded? |
30629
b6e5ad2f18d5
8076188: Optimize arraycopy out for non escaping destination
roland
parents:
30300
diff
changeset
|
187 |
|
b6e5ad2f18d5
8076188: Optimize arraycopy out for non escaping destination
roland
parents:
30300
diff
changeset
|
188 |
virtual Node* find_previous_arraycopy(PhaseTransform* phase, Node* ld_alloc, Node*& mem, bool can_see_stored_value) const; |
1 | 189 |
public: |
190 |
||
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
191 |
LoadNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *rt, MemOrd mo, ControlDependency control_dependency) |
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
192 |
: MemNode(c,mem,adr,at), _type(rt), _mo(mo), _control_dependency(control_dependency) { |
1 | 193 |
init_class_id(Class_Load); |
194 |
} |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
195 |
inline bool is_unordered() const { return !is_acquire(); } |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
196 |
inline bool is_acquire() const { |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
197 |
assert(_mo == unordered || _mo == acquire, "unexpected"); |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
198 |
return _mo == acquire; |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
199 |
} |
36831
6a71b98a4417
8152179: C2: Folding of unsigned loads is broken w/ @Stable
vlivanov
parents:
36830
diff
changeset
|
200 |
inline bool is_unsigned() const { |
6a71b98a4417
8152179: C2: Folding of unsigned loads is broken w/ @Stable
vlivanov
parents:
36830
diff
changeset
|
201 |
int lop = Opcode(); |
6a71b98a4417
8152179: C2: Folding of unsigned loads is broken w/ @Stable
vlivanov
parents:
36830
diff
changeset
|
202 |
return (lop == Op_LoadUB) || (lop == Op_LoadUS); |
6a71b98a4417
8152179: C2: Folding of unsigned loads is broken w/ @Stable
vlivanov
parents:
36830
diff
changeset
|
203 |
} |
1 | 204 |
|
205 |
// Polymorphic factory method: |
|
34189 | 206 |
static Node* make(PhaseGVN& gvn, Node *c, Node *mem, Node *adr, |
207 |
const TypePtr* at, const Type *rt, BasicType bt, |
|
208 |
MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, |
|
209 |
bool unaligned = false, bool mismatched = false); |
|
1 | 210 |
|
211 |
virtual uint hash() const; // Check the type |
|
212 |
||
213 |
// Handle algebraic identities here. If we have an identity, return the Node |
|
214 |
// we are equivalent to. We look for Load of a Store. |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
215 |
virtual Node* Identity(PhaseGVN* phase); |
1 | 216 |
|
27637
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
217 |
// If the load is from Field memory and the pointer is non-null, it might be possible to |
1 | 218 |
// zero out the control input. |
27637
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
219 |
// If the offset is constant and the base is an object allocation, |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
220 |
// try to hook me up to the exact initializing store. |
1 | 221 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
222 |
||
589 | 223 |
// Split instance field load through Phi. |
224 |
Node* split_through_phi(PhaseGVN *phase); |
|
225 |
||
190
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
226 |
// Recover original value from boxed values |
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
227 |
Node *eliminate_autobox(PhaseGVN *phase); |
e9a0a9dcd4f6
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
1
diff
changeset
|
228 |
|
1 | 229 |
// Compute a new Type for this node. Basically we just do the pre-check, |
230 |
// then call the virtual add() to set the type. |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
231 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 232 |
|
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
233 |
// Common methods for LoadKlass and LoadNKlass nodes. |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
234 |
const Type* klass_value_common(PhaseGVN* phase) const; |
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
235 |
Node* klass_identity_common(PhaseGVN* phase); |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
236 |
|
1 | 237 |
virtual uint ideal_reg() const; |
238 |
virtual const Type *bottom_type() const; |
|
239 |
// Following method is copied from TypeNode: |
|
240 |
void set_type(const Type* t) { |
|
241 |
assert(t != NULL, "sanity"); |
|
242 |
debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH); |
|
243 |
*(const Type**)&_type = t; // cast away const-ness |
|
244 |
// If this node is in the hash table, make sure it doesn't need a rehash. |
|
245 |
assert(check_hash == NO_HASH || check_hash == hash(), "type change must preserve hash code"); |
|
246 |
} |
|
247 |
const Type* type() const { assert(_type != NULL, "sanity"); return _type; }; |
|
248 |
||
249 |
// Do not match memory edge |
|
250 |
virtual uint match_edge(uint idx) const; |
|
251 |
||
252 |
// Map a load opcode to its corresponding store opcode. |
|
253 |
virtual int store_Opcode() const = 0; |
|
254 |
||
237
fba97e902303
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
206
diff
changeset
|
255 |
// Check if the load's memory input is a Phi node with the same control. |
fba97e902303
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
206
diff
changeset
|
256 |
bool is_instance_field_load_with_local_phi(Node* ctrl); |
fba97e902303
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
206
diff
changeset
|
257 |
|
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
258 |
Node* convert_to_unsigned_load(PhaseGVN& gvn); |
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
259 |
Node* convert_to_signed_load(PhaseGVN& gvn); |
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
260 |
|
1 | 261 |
#ifndef PRODUCT |
262 |
virtual void dump_spec(outputStream *st) const; |
|
263 |
#endif |
|
5889 | 264 |
#ifdef ASSERT |
265 |
// Helper function to allow a raw load without control edge for some cases |
|
266 |
static bool is_immutable_value(Node* adr); |
|
267 |
#endif |
|
1 | 268 |
protected: |
269 |
const Type* load_array_final_field(const TypeKlassPtr *tkls, |
|
270 |
ciKlass* klass) const; |
|
32370
38b7b5772b4f
8130847: Cloned object's fields observed as null after C2 escape analysis
roland
parents:
31035
diff
changeset
|
271 |
|
38b7b5772b4f
8130847: Cloned object's fields observed as null after C2 escape analysis
roland
parents:
31035
diff
changeset
|
272 |
Node* can_see_arraycopy_value(Node* st, PhaseTransform* phase) const; |
38b7b5772b4f
8130847: Cloned object's fields observed as null after C2 escape analysis
roland
parents:
31035
diff
changeset
|
273 |
|
21526
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
274 |
// depends_only_on_test is almost always true, and needs to be almost always |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
275 |
// true to enable key hoisting & commoning optimizations. However, for the |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
276 |
// special case of RawPtr loads from TLS top & end, and other loads performed by |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
277 |
// GC barriers, the control edge carries the dependence preventing hoisting past |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
278 |
// a Safepoint instead of the memory edge. (An unfortunate consequence of having |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
279 |
// Safepoints not set Raw Memory; itself an unfortunate consequence of having Nodes |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
280 |
// which produce results (new raw memory state) inside of loops preventing all |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
281 |
// manner of other optimizations). Basically, it's ugly but so is the alternative. |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
17383
diff
changeset
|
282 |
// See comment in macro.cpp, around line 125 expand_allocate_common(). |
36830
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
283 |
virtual bool depends_only_on_test() const { |
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
284 |
return adr_type() != TypeRawPtr::BOTTOM && _control_dependency == DependsOnlyOnTest; |
ebc8b5e23f63
8152773: C2: LoadNode properties aren't preserved when converting between signed/unsigned variants
vlivanov
parents:
36554
diff
changeset
|
285 |
} |
1 | 286 |
}; |
287 |
||
288 |
//------------------------------LoadBNode-------------------------------------- |
|
289 |
// Load a byte (8bits signed) from memory |
|
290 |
class LoadBNode : public LoadNode { |
|
291 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
292 |
LoadBNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
293 |
: LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} |
1 | 294 |
virtual int Opcode() const; |
295 |
virtual uint ideal_reg() const { return Op_RegI; } |
|
296 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
297 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 298 |
virtual int store_Opcode() const { return Op_StoreB; } |
299 |
virtual BasicType memory_type() const { return T_BYTE; } |
|
300 |
}; |
|
301 |
||
2150 | 302 |
//------------------------------LoadUBNode------------------------------------- |
303 |
// Load a unsigned byte (8bits unsigned) from memory |
|
304 |
class LoadUBNode : public LoadNode { |
|
305 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
306 |
LoadUBNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt* ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
307 |
: LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} |
2150 | 308 |
virtual int Opcode() const; |
309 |
virtual uint ideal_reg() const { return Op_RegI; } |
|
310 |
virtual Node* Ideal(PhaseGVN *phase, bool can_reshape); |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
311 |
virtual const Type* Value(PhaseGVN* phase) const; |
2150 | 312 |
virtual int store_Opcode() const { return Op_StoreB; } |
313 |
virtual BasicType memory_type() const { return T_BYTE; } |
|
314 |
}; |
|
315 |
||
2022
28ce8115a91d
6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents:
1500
diff
changeset
|
316 |
//------------------------------LoadUSNode------------------------------------- |
28ce8115a91d
6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents:
1500
diff
changeset
|
317 |
// Load an unsigned short/char (16bits unsigned) from memory |
28ce8115a91d
6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents:
1500
diff
changeset
|
318 |
class LoadUSNode : public LoadNode { |
1 | 319 |
public: |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
320 |
LoadUSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
321 |
: LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} |
1 | 322 |
virtual int Opcode() const; |
323 |
virtual uint ideal_reg() const { return Op_RegI; } |
|
324 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
325 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 326 |
virtual int store_Opcode() const { return Op_StoreC; } |
327 |
virtual BasicType memory_type() const { return T_CHAR; } |
|
328 |
}; |
|
329 |
||
11562 | 330 |
//------------------------------LoadSNode-------------------------------------- |
331 |
// Load a short (16bits signed) from memory |
|
332 |
class LoadSNode : public LoadNode { |
|
333 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
334 |
LoadSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
335 |
: LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} |
11562 | 336 |
virtual int Opcode() const; |
337 |
virtual uint ideal_reg() const { return Op_RegI; } |
|
338 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
339 |
virtual const Type* Value(PhaseGVN* phase) const; |
11562 | 340 |
virtual int store_Opcode() const { return Op_StoreC; } |
341 |
virtual BasicType memory_type() const { return T_SHORT; } |
|
342 |
}; |
|
343 |
||
1 | 344 |
//------------------------------LoadINode-------------------------------------- |
345 |
// Load an integer from memory |
|
346 |
class LoadINode : public LoadNode { |
|
347 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
348 |
LoadINode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
349 |
: LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} |
1 | 350 |
virtual int Opcode() const; |
351 |
virtual uint ideal_reg() const { return Op_RegI; } |
|
352 |
virtual int store_Opcode() const { return Op_StoreI; } |
|
353 |
virtual BasicType memory_type() const { return T_INT; } |
|
354 |
}; |
|
355 |
||
356 |
//------------------------------LoadRangeNode---------------------------------- |
|
357 |
// Load an array length from the array |
|
358 |
class LoadRangeNode : public LoadINode { |
|
359 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
360 |
LoadRangeNode(Node *c, Node *mem, Node *adr, const TypeInt *ti = TypeInt::POS) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
361 |
: LoadINode(c, mem, adr, TypeAryPtr::RANGE, ti, MemNode::unordered) {} |
1 | 362 |
virtual int Opcode() const; |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
363 |
virtual const Type* Value(PhaseGVN* phase) const; |
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
364 |
virtual Node* Identity(PhaseGVN* phase); |
1398
342890a5d031
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
961
diff
changeset
|
365 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
1 | 366 |
}; |
367 |
||
368 |
//------------------------------LoadLNode-------------------------------------- |
|
369 |
// Load a long from memory |
|
370 |
class LoadLNode : public LoadNode { |
|
371 |
virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; } |
|
372 |
virtual uint cmp( const Node &n ) const { |
|
373 |
return _require_atomic_access == ((LoadLNode&)n)._require_atomic_access |
|
374 |
&& LoadNode::cmp(n); |
|
375 |
} |
|
376 |
virtual uint size_of() const { return sizeof(*this); } |
|
377 |
const bool _require_atomic_access; // is piecewise load forbidden? |
|
378 |
||
379 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
380 |
LoadLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeLong *tl, |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
381 |
MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
382 |
: LoadNode(c, mem, adr, at, tl, mo, control_dependency), _require_atomic_access(require_atomic_access) {} |
1 | 383 |
virtual int Opcode() const; |
384 |
virtual uint ideal_reg() const { return Op_RegL; } |
|
385 |
virtual int store_Opcode() const { return Op_StoreL; } |
|
386 |
virtual BasicType memory_type() const { return T_LONG; } |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
387 |
bool require_atomic_access() const { return _require_atomic_access; } |
25930 | 388 |
static LoadLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, |
34189 | 389 |
const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, |
390 |
bool unaligned = false, bool mismatched = false); |
|
1 | 391 |
#ifndef PRODUCT |
392 |
virtual void dump_spec(outputStream *st) const { |
|
393 |
LoadNode::dump_spec(st); |
|
394 |
if (_require_atomic_access) st->print(" Atomic!"); |
|
395 |
} |
|
396 |
#endif |
|
397 |
}; |
|
398 |
||
399 |
//------------------------------LoadL_unalignedNode---------------------------- |
|
400 |
// Load a long from unaligned memory |
|
401 |
class LoadL_unalignedNode : public LoadLNode { |
|
402 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
403 |
LoadL_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
404 |
: LoadLNode(c, mem, adr, at, TypeLong::LONG, mo, control_dependency) {} |
1 | 405 |
virtual int Opcode() const; |
406 |
}; |
|
407 |
||
408 |
//------------------------------LoadFNode-------------------------------------- |
|
409 |
// Load a float (64 bits) from memory |
|
410 |
class LoadFNode : public LoadNode { |
|
411 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
412 |
LoadFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
413 |
: LoadNode(c, mem, adr, at, t, mo, control_dependency) {} |
1 | 414 |
virtual int Opcode() const; |
415 |
virtual uint ideal_reg() const { return Op_RegF; } |
|
416 |
virtual int store_Opcode() const { return Op_StoreF; } |
|
417 |
virtual BasicType memory_type() const { return T_FLOAT; } |
|
418 |
}; |
|
419 |
||
420 |
//------------------------------LoadDNode-------------------------------------- |
|
421 |
// Load a double (64 bits) from memory |
|
422 |
class LoadDNode : public LoadNode { |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
423 |
virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; } |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
424 |
virtual uint cmp( const Node &n ) const { |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
425 |
return _require_atomic_access == ((LoadDNode&)n)._require_atomic_access |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
426 |
&& LoadNode::cmp(n); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
427 |
} |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
428 |
virtual uint size_of() const { return sizeof(*this); } |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
429 |
const bool _require_atomic_access; // is piecewise load forbidden? |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
430 |
|
1 | 431 |
public: |
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
432 |
LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
433 |
MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
434 |
: LoadNode(c, mem, adr, at, t, mo, control_dependency), _require_atomic_access(require_atomic_access) {} |
1 | 435 |
virtual int Opcode() const; |
436 |
virtual uint ideal_reg() const { return Op_RegD; } |
|
437 |
virtual int store_Opcode() const { return Op_StoreD; } |
|
438 |
virtual BasicType memory_type() const { return T_DOUBLE; } |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
439 |
bool require_atomic_access() const { return _require_atomic_access; } |
25930 | 440 |
static LoadDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, |
34189 | 441 |
const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, |
442 |
bool unaligned = false, bool mismatched = false); |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
443 |
#ifndef PRODUCT |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
444 |
virtual void dump_spec(outputStream *st) const { |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
445 |
LoadNode::dump_spec(st); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
446 |
if (_require_atomic_access) st->print(" Atomic!"); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
447 |
} |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
448 |
#endif |
1 | 449 |
}; |
450 |
||
451 |
//------------------------------LoadD_unalignedNode---------------------------- |
|
452 |
// Load a double from unaligned memory |
|
453 |
class LoadD_unalignedNode : public LoadDNode { |
|
454 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
455 |
LoadD_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
456 |
: LoadDNode(c, mem, adr, at, Type::DOUBLE, mo, control_dependency) {} |
1 | 457 |
virtual int Opcode() const; |
458 |
}; |
|
459 |
||
460 |
//------------------------------LoadPNode-------------------------------------- |
|
461 |
// Load a pointer from memory (either object or array) |
|
462 |
class LoadPNode : public LoadNode { |
|
463 |
public: |
|
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
464 |
LoadPNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
465 |
: LoadNode(c, mem, adr, at, t, mo, control_dependency) {} |
1 | 466 |
virtual int Opcode() const; |
467 |
virtual uint ideal_reg() const { return Op_RegP; } |
|
468 |
virtual int store_Opcode() const { return Op_StoreP; } |
|
469 |
virtual BasicType memory_type() const { return T_ADDRESS; } |
|
470 |
}; |
|
471 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
472 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
473 |
//------------------------------LoadNNode-------------------------------------- |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
474 |
// Load a narrow oop from memory (either object or array) |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
475 |
class LoadNNode : public LoadNode { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
476 |
public: |
31035
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
477 |
LoadNNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const Type* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) |
0f0743952c41
8077504: Unsafe load can loose control dependency and cause crash
roland
parents:
30629
diff
changeset
|
478 |
: LoadNode(c, mem, adr, at, t, mo, control_dependency) {} |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
479 |
virtual int Opcode() const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
480 |
virtual uint ideal_reg() const { return Op_RegN; } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
481 |
virtual int store_Opcode() const { return Op_StoreN; } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
482 |
virtual BasicType memory_type() const { return T_NARROWOOP; } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
483 |
}; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
484 |
|
1 | 485 |
//------------------------------LoadKlassNode---------------------------------- |
486 |
// Load a Klass from an object |
|
487 |
class LoadKlassNode : public LoadPNode { |
|
27637
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
488 |
protected: |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
489 |
// In most cases, LoadKlassNode does not have the control input set. If the control |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
490 |
// input is set, it must not be removed (by LoadNode::Ideal()). |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
491 |
virtual bool can_remove_control() const; |
1 | 492 |
public: |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
493 |
LoadKlassNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
494 |
: LoadPNode(c, mem, adr, at, tk, mo) {} |
1 | 495 |
virtual int Opcode() const; |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
496 |
virtual const Type* Value(PhaseGVN* phase) const; |
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
497 |
virtual Node* Identity(PhaseGVN* phase); |
1 | 498 |
virtual bool depends_only_on_test() const { return true; } |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
499 |
|
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
500 |
// Polymorphic factory method: |
27637
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
501 |
static Node* make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* at, |
cf68c0af6882
8057622: java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest: SEGV inside compiled code (sparc)
zmajo
parents:
25930
diff
changeset
|
502 |
const TypeKlassPtr* tk = TypeKlassPtr::OBJECT); |
1 | 503 |
}; |
504 |
||
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
505 |
//------------------------------LoadNKlassNode--------------------------------- |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
506 |
// Load a narrow Klass from an object. |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
507 |
class LoadNKlassNode : public LoadNNode { |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
508 |
public: |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
509 |
LoadNKlassNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeNarrowKlass *tk, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
510 |
: LoadNNode(c, mem, adr, at, tk, mo) {} |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
511 |
virtual int Opcode() const; |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
512 |
virtual uint ideal_reg() const { return Op_RegN; } |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
513 |
virtual int store_Opcode() const { return Op_StoreNKlass; } |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
514 |
virtual BasicType memory_type() const { return T_NARROWKLASS; } |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
515 |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
516 |
virtual const Type* Value(PhaseGVN* phase) const; |
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
517 |
virtual Node* Identity(PhaseGVN* phase); |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
518 |
virtual bool depends_only_on_test() const { return true; } |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
519 |
}; |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
520 |
|
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
521 |
|
1 | 522 |
//------------------------------StoreNode-------------------------------------- |
523 |
// Store value; requires Store, Address and Value |
|
524 |
class StoreNode : public MemNode { |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
525 |
private: |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
526 |
// On platforms with weak memory ordering (e.g., PPC, Ia64) we distinguish |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
527 |
// stores that can be reordered, and such requiring release semantics to |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
528 |
// adhere to the Java specification. The required behaviour is stored in |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
529 |
// this field. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
530 |
const MemOrd _mo; |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
531 |
// Needed for proper cloning. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
532 |
virtual uint size_of() const { return sizeof(*this); } |
1 | 533 |
protected: |
534 |
virtual uint cmp( const Node &n ) const; |
|
535 |
virtual bool depends_only_on_test() const { return false; } |
|
536 |
||
537 |
Node *Ideal_masked_input (PhaseGVN *phase, uint mask); |
|
538 |
Node *Ideal_sign_extended_input(PhaseGVN *phase, int num_bits); |
|
539 |
||
540 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
541 |
// We must ensure that stores of object references will be visible |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
542 |
// only after the object's initialization. So the callers of this |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
543 |
// procedure must indicate that the store requires `release' |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
544 |
// semantics, if the stored value is an object reference that might |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
545 |
// point to a new object and may become externally visible. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
546 |
StoreNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
547 |
: MemNode(c, mem, adr, at, val), _mo(mo) { |
1 | 548 |
init_class_id(Class_Store); |
549 |
} |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
550 |
StoreNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, Node *oop_store, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
551 |
: MemNode(c, mem, adr, at, val, oop_store), _mo(mo) { |
1 | 552 |
init_class_id(Class_Store); |
553 |
} |
|
554 |
||
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
555 |
inline bool is_unordered() const { return !is_release(); } |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
556 |
inline bool is_release() const { |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
557 |
assert((_mo == unordered || _mo == release), "unexpected"); |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
558 |
return _mo == release; |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
559 |
} |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
560 |
|
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
561 |
// Conservatively release stores of object references in order to |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
562 |
// ensure visibility of object initialization. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
563 |
static inline MemOrd release_if_reference(const BasicType t) { |
29180 | 564 |
#ifdef AARCH64 |
565 |
// AArch64 doesn't need a release store here because object |
|
566 |
// initialization contains the necessary barriers. |
|
567 |
return unordered; |
|
568 |
#else |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
569 |
const MemOrd mo = (t == T_ARRAY || |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
570 |
t == T_ADDRESS || // Might be the address of an object reference (`boxing'). |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
571 |
t == T_OBJECT) ? release : unordered; |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
572 |
return mo; |
29180 | 573 |
#endif |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
574 |
} |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
575 |
|
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
576 |
// Polymorphic factory method |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
577 |
// |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
578 |
// We must ensure that stores of object references will be visible |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
579 |
// only after the object's initialization. So the callers of this |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
580 |
// procedure must indicate that the store requires `release' |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
581 |
// semantics, if the stored value is an object reference that might |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
582 |
// point to a new object and may become externally visible. |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
583 |
static StoreNode* make(PhaseGVN& gvn, Node *c, Node *mem, Node *adr, |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
584 |
const TypePtr* at, Node *val, BasicType bt, MemOrd mo); |
1 | 585 |
|
586 |
virtual uint hash() const; // Check the type |
|
587 |
||
588 |
// If the store is to Field memory and the pointer is non-null, we can |
|
589 |
// zero out the control input. |
|
590 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
591 |
||
592 |
// Compute a new Type for this node. Basically we just do the pre-check, |
|
593 |
// then call the virtual add() to set the type. |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
594 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 595 |
|
596 |
// Check for identity function on memory (Load then Store at same address) |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
597 |
virtual Node* Identity(PhaseGVN* phase); |
1 | 598 |
|
599 |
// Do not match memory edge |
|
600 |
virtual uint match_edge(uint idx) const; |
|
601 |
||
602 |
virtual const Type *bottom_type() const; // returns Type::MEMORY |
|
603 |
||
604 |
// Map a store opcode to its corresponding own opcode, trivially. |
|
605 |
virtual int store_Opcode() const { return Opcode(); } |
|
606 |
||
607 |
// have all possible loads of the value stored been optimized away? |
|
608 |
bool value_never_loaded(PhaseTransform *phase) const; |
|
609 |
}; |
|
610 |
||
611 |
//------------------------------StoreBNode------------------------------------- |
|
612 |
// Store byte to memory |
|
613 |
class StoreBNode : public StoreNode { |
|
614 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
615 |
StoreBNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
616 |
: StoreNode(c, mem, adr, at, val, mo) {} |
1 | 617 |
virtual int Opcode() const; |
618 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
619 |
virtual BasicType memory_type() const { return T_BYTE; } |
|
620 |
}; |
|
621 |
||
622 |
//------------------------------StoreCNode------------------------------------- |
|
623 |
// Store char/short to memory |
|
624 |
class StoreCNode : public StoreNode { |
|
625 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
626 |
StoreCNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
627 |
: StoreNode(c, mem, adr, at, val, mo) {} |
1 | 628 |
virtual int Opcode() const; |
629 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
|
630 |
virtual BasicType memory_type() const { return T_CHAR; } |
|
631 |
}; |
|
632 |
||
633 |
//------------------------------StoreINode------------------------------------- |
|
634 |
// Store int to memory |
|
635 |
class StoreINode : public StoreNode { |
|
636 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
637 |
StoreINode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
638 |
: StoreNode(c, mem, adr, at, val, mo) {} |
1 | 639 |
virtual int Opcode() const; |
640 |
virtual BasicType memory_type() const { return T_INT; } |
|
641 |
}; |
|
642 |
||
643 |
//------------------------------StoreLNode------------------------------------- |
|
644 |
// Store long to memory |
|
645 |
class StoreLNode : public StoreNode { |
|
646 |
virtual uint hash() const { return StoreNode::hash() + _require_atomic_access; } |
|
647 |
virtual uint cmp( const Node &n ) const { |
|
648 |
return _require_atomic_access == ((StoreLNode&)n)._require_atomic_access |
|
649 |
&& StoreNode::cmp(n); |
|
650 |
} |
|
651 |
virtual uint size_of() const { return sizeof(*this); } |
|
652 |
const bool _require_atomic_access; // is piecewise store forbidden? |
|
653 |
||
654 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
655 |
StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
656 |
: StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {} |
1 | 657 |
virtual int Opcode() const; |
658 |
virtual BasicType memory_type() const { return T_LONG; } |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
659 |
bool require_atomic_access() const { return _require_atomic_access; } |
25930 | 660 |
static StoreLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo); |
1 | 661 |
#ifndef PRODUCT |
662 |
virtual void dump_spec(outputStream *st) const { |
|
663 |
StoreNode::dump_spec(st); |
|
664 |
if (_require_atomic_access) st->print(" Atomic!"); |
|
665 |
} |
|
666 |
#endif |
|
667 |
}; |
|
668 |
||
669 |
//------------------------------StoreFNode------------------------------------- |
|
670 |
// Store float to memory |
|
671 |
class StoreFNode : public StoreNode { |
|
672 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
673 |
StoreFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
674 |
: StoreNode(c, mem, adr, at, val, mo) {} |
1 | 675 |
virtual int Opcode() const; |
676 |
virtual BasicType memory_type() const { return T_FLOAT; } |
|
677 |
}; |
|
678 |
||
679 |
//------------------------------StoreDNode------------------------------------- |
|
680 |
// Store double to memory |
|
681 |
class StoreDNode : public StoreNode { |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
682 |
virtual uint hash() const { return StoreNode::hash() + _require_atomic_access; } |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
683 |
virtual uint cmp( const Node &n ) const { |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
684 |
return _require_atomic_access == ((StoreDNode&)n)._require_atomic_access |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
685 |
&& StoreNode::cmp(n); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
686 |
} |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
687 |
virtual uint size_of() const { return sizeof(*this); } |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
688 |
const bool _require_atomic_access; // is piecewise store forbidden? |
1 | 689 |
public: |
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
690 |
StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
691 |
MemOrd mo, bool require_atomic_access = false) |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
692 |
: StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {} |
1 | 693 |
virtual int Opcode() const; |
694 |
virtual BasicType memory_type() const { return T_DOUBLE; } |
|
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
695 |
bool require_atomic_access() const { return _require_atomic_access; } |
25930 | 696 |
static StoreDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo); |
24345
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
697 |
#ifndef PRODUCT |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
698 |
virtual void dump_spec(outputStream *st) const { |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
699 |
StoreNode::dump_spec(st); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
700 |
if (_require_atomic_access) st->print(" Atomic!"); |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
701 |
} |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
702 |
#endif |
616bc709c0e4
8036851: volatile double accesses are not explicitly atomic in C2
anoll
parents:
23528
diff
changeset
|
703 |
|
1 | 704 |
}; |
705 |
||
706 |
//------------------------------StorePNode------------------------------------- |
|
707 |
// Store pointer to memory |
|
708 |
class StorePNode : public StoreNode { |
|
709 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
710 |
StorePNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
711 |
: StoreNode(c, mem, adr, at, val, mo) {} |
1 | 712 |
virtual int Opcode() const; |
713 |
virtual BasicType memory_type() const { return T_ADDRESS; } |
|
714 |
}; |
|
715 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
716 |
//------------------------------StoreNNode------------------------------------- |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
717 |
// Store narrow oop to memory |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
718 |
class StoreNNode : public StoreNode { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
719 |
public: |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
720 |
StoreNNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
721 |
: StoreNode(c, mem, adr, at, val, mo) {} |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
722 |
virtual int Opcode() const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
723 |
virtual BasicType memory_type() const { return T_NARROWOOP; } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
724 |
}; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
725 |
|
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
726 |
//------------------------------StoreNKlassNode-------------------------------------- |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
727 |
// Store narrow klass to memory |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
728 |
class StoreNKlassNode : public StoreNNode { |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
729 |
public: |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
730 |
StoreNKlassNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
731 |
: StoreNNode(c, mem, adr, at, val, mo) {} |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
732 |
virtual int Opcode() const; |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
733 |
virtual BasicType memory_type() const { return T_NARROWKLASS; } |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
734 |
}; |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13886
diff
changeset
|
735 |
|
1 | 736 |
//------------------------------StoreCMNode----------------------------------- |
737 |
// Store card-mark byte to memory for CM |
|
738 |
// The last StoreCM before a SafePoint must be preserved and occur after its "oop" store |
|
739 |
// Preceeding equivalent StoreCMs may be eliminated. |
|
740 |
class StoreCMNode : public StoreNode { |
|
3904
007a45522a7f
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
2348
diff
changeset
|
741 |
private: |
4746
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
742 |
virtual uint hash() const { return StoreNode::hash() + _oop_alias_idx; } |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
743 |
virtual uint cmp( const Node &n ) const { |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
744 |
return _oop_alias_idx == ((StoreCMNode&)n)._oop_alias_idx |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
745 |
&& StoreNode::cmp(n); |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
746 |
} |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
747 |
virtual uint size_of() const { return sizeof(*this); } |
3904
007a45522a7f
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
2348
diff
changeset
|
748 |
int _oop_alias_idx; // The alias_idx of OopStore |
4746
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
749 |
|
1 | 750 |
public: |
4746
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
751 |
StoreCMNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, Node *oop_store, int oop_alias_idx ) : |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
752 |
StoreNode(c, mem, adr, at, val, oop_store, MemNode::release), |
4746
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
753 |
_oop_alias_idx(oop_alias_idx) { |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
754 |
assert(_oop_alias_idx >= Compile::AliasIdxRaw || |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
755 |
_oop_alias_idx == Compile::AliasIdxBot && Compile::current()->AliasLevel() == 0, |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
756 |
"bad oop alias idx"); |
c1d5f1b38289
6920346: G1: "must avoid base_memory and AliasIdxTop"
never
parents:
4470
diff
changeset
|
757 |
} |
1 | 758 |
virtual int Opcode() const; |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
759 |
virtual Node* Identity(PhaseGVN* phase); |
3904
007a45522a7f
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
2348
diff
changeset
|
760 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
761 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 762 |
virtual BasicType memory_type() const { return T_VOID; } // unspecific |
3904
007a45522a7f
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
2348
diff
changeset
|
763 |
int oop_alias_idx() const { return _oop_alias_idx; } |
1 | 764 |
}; |
765 |
||
766 |
//------------------------------LoadPLockedNode--------------------------------- |
|
767 |
// Load-locked a pointer from memory (either object or array). |
|
768 |
// On Sparc & Intel this is implemented as a normal pointer load. |
|
769 |
// On PowerPC and friends it's a real load-locked. |
|
770 |
class LoadPLockedNode : public LoadPNode { |
|
771 |
public: |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
772 |
LoadPLockedNode(Node *c, Node *mem, Node *adr, MemOrd mo) |
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
17383
diff
changeset
|
773 |
: LoadPNode(c, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, mo) {} |
1 | 774 |
virtual int Opcode() const; |
775 |
virtual int store_Opcode() const { return Op_StorePConditional; } |
|
776 |
virtual bool depends_only_on_test() const { return true; } |
|
777 |
}; |
|
778 |
||
779 |
//------------------------------SCMemProjNode--------------------------------------- |
|
780 |
// This class defines a projection of the memory state of a store conditional node. |
|
781 |
// These nodes return a value, but also update memory. |
|
782 |
class SCMemProjNode : public ProjNode { |
|
783 |
public: |
|
784 |
enum {SCMEMPROJCON = (uint)-2}; |
|
785 |
SCMemProjNode( Node *src) : ProjNode( src, SCMEMPROJCON) { } |
|
786 |
virtual int Opcode() const; |
|
787 |
virtual bool is_CFG() const { return false; } |
|
788 |
virtual const Type *bottom_type() const {return Type::MEMORY;} |
|
27697
ae60f551e5c8
8062258: compiler/debug/TraceIterativeGVN.java segfaults in trace_PhaseIterGVN
vlivanov
parents:
27637
diff
changeset
|
789 |
virtual const TypePtr *adr_type() const { |
ae60f551e5c8
8062258: compiler/debug/TraceIterativeGVN.java segfaults in trace_PhaseIterGVN
vlivanov
parents:
27637
diff
changeset
|
790 |
Node* ctrl = in(0); |
ae60f551e5c8
8062258: compiler/debug/TraceIterativeGVN.java segfaults in trace_PhaseIterGVN
vlivanov
parents:
27637
diff
changeset
|
791 |
if (ctrl == NULL) return NULL; // node is dead |
ae60f551e5c8
8062258: compiler/debug/TraceIterativeGVN.java segfaults in trace_PhaseIterGVN
vlivanov
parents:
27637
diff
changeset
|
792 |
return ctrl->in(MemNode::Memory)->adr_type(); |
ae60f551e5c8
8062258: compiler/debug/TraceIterativeGVN.java segfaults in trace_PhaseIterGVN
vlivanov
parents:
27637
diff
changeset
|
793 |
} |
1 | 794 |
virtual uint ideal_reg() const { return 0;} // memory projections don't have a register |
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
795 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 796 |
#ifndef PRODUCT |
797 |
virtual void dump_spec(outputStream *st) const {}; |
|
798 |
#endif |
|
799 |
}; |
|
800 |
||
801 |
//------------------------------LoadStoreNode--------------------------- |
|
961
7fb3b13d4205
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
670
diff
changeset
|
802 |
// Note: is_Mem() method returns 'true' for this class. |
1 | 803 |
class LoadStoreNode : public Node { |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
804 |
private: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
805 |
const Type* const _type; // What kind of value is loaded? |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
806 |
const TypePtr* _adr_type; // What kind of memory is being addressed? |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
807 |
virtual uint size_of() const; // Size is bigger |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
808 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
809 |
LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required ); |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
810 |
virtual bool depends_only_on_test() const { return false; } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
811 |
virtual uint match_edge(uint idx) const { return idx == MemNode::Address || idx == MemNode::ValueIn; } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
812 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
813 |
virtual const Type *bottom_type() const { return _type; } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
814 |
virtual uint ideal_reg() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
815 |
virtual const class TypePtr *adr_type() const { return _adr_type; } // returns bottom_type of address |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
816 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
817 |
bool result_not_used() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
818 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
819 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
820 |
class LoadStoreConditionalNode : public LoadStoreNode { |
1 | 821 |
public: |
822 |
enum { |
|
823 |
ExpectedIn = MemNode::ValueIn+1 // One more input than MemNode |
|
824 |
}; |
|
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
825 |
LoadStoreConditionalNode(Node *c, Node *mem, Node *adr, Node *val, Node *ex); |
1 | 826 |
}; |
827 |
||
828 |
//------------------------------StorePConditionalNode--------------------------- |
|
829 |
// Conditionally store pointer to memory, if no change since prior |
|
830 |
// load-locked. Sets flags for success or failure of the store. |
|
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
831 |
class StorePConditionalNode : public LoadStoreConditionalNode { |
1 | 832 |
public: |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
833 |
StorePConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } |
1 | 834 |
virtual int Opcode() const; |
835 |
// Produces flags |
|
836 |
virtual uint ideal_reg() const { return Op_RegFlags; } |
|
837 |
}; |
|
838 |
||
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
839 |
//------------------------------StoreIConditionalNode--------------------------- |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
840 |
// Conditionally store int to memory, if no change since prior |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
841 |
// load-locked. Sets flags for success or failure of the store. |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
842 |
class StoreIConditionalNode : public LoadStoreConditionalNode { |
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
843 |
public: |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
844 |
StoreIConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ii ) : LoadStoreConditionalNode(c, mem, adr, val, ii) { } |
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
845 |
virtual int Opcode() const; |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
846 |
// Produces flags |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
847 |
virtual uint ideal_reg() const { return Op_RegFlags; } |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
848 |
}; |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
849 |
|
1 | 850 |
//------------------------------StoreLConditionalNode--------------------------- |
851 |
// Conditionally store long to memory, if no change since prior |
|
852 |
// load-locked. Sets flags for success or failure of the store. |
|
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
853 |
class StoreLConditionalNode : public LoadStoreConditionalNode { |
1 | 854 |
public: |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
855 |
StoreLConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } |
1 | 856 |
virtual int Opcode() const; |
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
857 |
// Produces flags |
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1398
diff
changeset
|
858 |
virtual uint ideal_reg() const { return Op_RegFlags; } |
1 | 859 |
}; |
860 |
||
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
861 |
class CompareAndSwapNode : public LoadStoreConditionalNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
862 |
private: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
863 |
const MemNode::MemOrd _mem_ord; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
864 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
865 |
CompareAndSwapNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : LoadStoreConditionalNode(c, mem, adr, val, ex), _mem_ord(mem_ord) {} |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
866 |
MemNode::MemOrd order() const { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
867 |
return _mem_ord; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
868 |
} |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
869 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
870 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
871 |
class CompareAndExchangeNode : public LoadStoreNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
872 |
private: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
873 |
const MemNode::MemOrd _mem_ord; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
874 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
875 |
enum { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
876 |
ExpectedIn = MemNode::ValueIn+1 // One more input than MemNode |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
877 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
878 |
CompareAndExchangeNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord, const TypePtr* at, const Type* t) : |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
879 |
LoadStoreNode(c, mem, adr, val, at, t, 5), _mem_ord(mem_ord) { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
880 |
init_req(ExpectedIn, ex ); |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
881 |
} |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
882 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
883 |
MemNode::MemOrd order() const { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
884 |
return _mem_ord; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
885 |
} |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
886 |
}; |
1 | 887 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
888 |
//------------------------------CompareAndSwapBNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
889 |
class CompareAndSwapBNode : public CompareAndSwapNode { |
1 | 890 |
public: |
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
891 |
CompareAndSwapBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
1 | 892 |
virtual int Opcode() const; |
893 |
}; |
|
894 |
||
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
895 |
//------------------------------CompareAndSwapSNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
896 |
class CompareAndSwapSNode : public CompareAndSwapNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
897 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
898 |
CompareAndSwapSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
899 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
900 |
}; |
1 | 901 |
|
902 |
//------------------------------CompareAndSwapINode--------------------------- |
|
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
903 |
class CompareAndSwapINode : public CompareAndSwapNode { |
1 | 904 |
public: |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
905 |
CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
1 | 906 |
virtual int Opcode() const; |
907 |
}; |
|
908 |
||
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
909 |
//------------------------------CompareAndSwapLNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
910 |
class CompareAndSwapLNode : public CompareAndSwapNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
911 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
912 |
CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
913 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
914 |
}; |
1 | 915 |
|
916 |
//------------------------------CompareAndSwapPNode--------------------------- |
|
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
917 |
class CompareAndSwapPNode : public CompareAndSwapNode { |
1 | 918 |
public: |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
919 |
CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
1 | 920 |
virtual int Opcode() const; |
921 |
}; |
|
922 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
923 |
//------------------------------CompareAndSwapNNode--------------------------- |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
924 |
class CompareAndSwapNNode : public CompareAndSwapNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
925 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
926 |
CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
927 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
928 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
929 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
930 |
//------------------------------WeakCompareAndSwapBNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
931 |
class WeakCompareAndSwapBNode : public CompareAndSwapNode { |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
932 |
public: |
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
933 |
WeakCompareAndSwapBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
934 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
935 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
936 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
937 |
//------------------------------WeakCompareAndSwapSNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
938 |
class WeakCompareAndSwapSNode : public CompareAndSwapNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
939 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
940 |
WeakCompareAndSwapSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
941 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
942 |
}; |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
943 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
944 |
//------------------------------WeakCompareAndSwapINode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
945 |
class WeakCompareAndSwapINode : public CompareAndSwapNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
946 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
947 |
WeakCompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
948 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
949 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
950 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
951 |
//------------------------------WeakCompareAndSwapLNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
952 |
class WeakCompareAndSwapLNode : public CompareAndSwapNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
953 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
954 |
WeakCompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
955 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
956 |
}; |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
957 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
958 |
//------------------------------WeakCompareAndSwapPNode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
959 |
class WeakCompareAndSwapPNode : public CompareAndSwapNode { |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
960 |
public: |
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
961 |
WeakCompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
962 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
963 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
964 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
965 |
//------------------------------WeakCompareAndSwapNNode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
966 |
class WeakCompareAndSwapNNode : public CompareAndSwapNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
967 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
968 |
WeakCompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
969 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
970 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
971 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
972 |
//------------------------------CompareAndExchangeBNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
973 |
class CompareAndExchangeBNode : public CompareAndExchangeNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
974 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
975 |
CompareAndExchangeBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::BYTE) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
976 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
977 |
}; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
978 |
|
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
979 |
|
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
980 |
//------------------------------CompareAndExchangeSNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
981 |
class CompareAndExchangeSNode : public CompareAndExchangeNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
982 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
983 |
CompareAndExchangeSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::SHORT) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
984 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
985 |
}; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
986 |
|
36316
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
987 |
//------------------------------CompareAndExchangeLNode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
988 |
class CompareAndExchangeLNode : public CompareAndExchangeNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
989 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
990 |
CompareAndExchangeLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeLong::LONG) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
991 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
992 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
993 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
994 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
995 |
//------------------------------CompareAndExchangeINode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
996 |
class CompareAndExchangeINode : public CompareAndExchangeNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
997 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
998 |
CompareAndExchangeINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::INT) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
999 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1000 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1001 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1002 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1003 |
//------------------------------CompareAndExchangePNode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1004 |
class CompareAndExchangePNode : public CompareAndExchangeNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1005 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1006 |
CompareAndExchangePNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { } |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1007 |
virtual int Opcode() const; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1008 |
}; |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1009 |
|
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1010 |
//------------------------------CompareAndExchangeNNode--------------------------- |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1011 |
class CompareAndExchangeNNode : public CompareAndExchangeNode { |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1012 |
public: |
7a83de7aabca
8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents:
35551
diff
changeset
|
1013 |
CompareAndExchangeNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { } |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1014 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1015 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1016 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1017 |
//------------------------------GetAndAddBNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1018 |
class GetAndAddBNode : public LoadStoreNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1019 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1020 |
GetAndAddBNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::BYTE, 4) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1021 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1022 |
}; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1023 |
|
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1024 |
//------------------------------GetAndAddSNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1025 |
class GetAndAddSNode : public LoadStoreNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1026 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1027 |
GetAndAddSNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::SHORT, 4) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1028 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1029 |
}; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1030 |
|
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1031 |
//------------------------------GetAndAddINode--------------------------- |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1032 |
class GetAndAddINode : public LoadStoreNode { |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1033 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1034 |
GetAndAddINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1035 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1036 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1037 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1038 |
//------------------------------GetAndAddLNode--------------------------- |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1039 |
class GetAndAddLNode : public LoadStoreNode { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
1040 |
public: |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1041 |
GetAndAddLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1042 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1043 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1044 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1045 |
//------------------------------GetAndSetBNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1046 |
class GetAndSetBNode : public LoadStoreNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1047 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1048 |
GetAndSetBNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::BYTE, 4) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1049 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1050 |
}; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1051 |
|
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1052 |
//------------------------------GetAndSetSNode--------------------------- |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1053 |
class GetAndSetSNode : public LoadStoreNode { |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1054 |
public: |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1055 |
GetAndSetSNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::SHORT, 4) { } |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1056 |
virtual int Opcode() const; |
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1057 |
}; |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1058 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1059 |
//------------------------------GetAndSetINode--------------------------- |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1060 |
class GetAndSetINode : public LoadStoreNode { |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1061 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1062 |
GetAndSetINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1063 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1064 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1065 |
|
39419
cc993a4ab581
8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents:
38017
diff
changeset
|
1066 |
//------------------------------GetAndSetLNode--------------------------- |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1067 |
class GetAndSetLNode : public LoadStoreNode { |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1068 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1069 |
GetAndSetLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1070 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1071 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1072 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1073 |
//------------------------------GetAndSetPNode--------------------------- |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1074 |
class GetAndSetPNode : public LoadStoreNode { |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1075 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1076 |
GetAndSetPNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1077 |
virtual int Opcode() const; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1078 |
}; |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1079 |
|
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1080 |
//------------------------------GetAndSetNNode--------------------------- |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1081 |
class GetAndSetNNode : public LoadStoreNode { |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1082 |
public: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
12957
diff
changeset
|
1083 |
GetAndSetNNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
1084 |
virtual int Opcode() const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
1085 |
}; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
247
diff
changeset
|
1086 |
|
1 | 1087 |
//------------------------------ClearArray------------------------------------- |
1088 |
class ClearArrayNode: public Node { |
|
36554
a7eb9ee4680c
8146801: Allocating short arrays of non-constant size is slow
shade
parents:
36316
diff
changeset
|
1089 |
private: |
a7eb9ee4680c
8146801: Allocating short arrays of non-constant size is slow
shade
parents:
36316
diff
changeset
|
1090 |
bool _is_large; |
1 | 1091 |
public: |
36554
a7eb9ee4680c
8146801: Allocating short arrays of non-constant size is slow
shade
parents:
36316
diff
changeset
|
1092 |
ClearArrayNode( Node *ctrl, Node *arymem, Node *word_cnt, Node *base, bool is_large) |
a7eb9ee4680c
8146801: Allocating short arrays of non-constant size is slow
shade
parents:
36316
diff
changeset
|
1093 |
: Node(ctrl,arymem,word_cnt,base), _is_large(is_large) { |
4470
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
3905
diff
changeset
|
1094 |
init_class_id(Class_ClearArray); |
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
3905
diff
changeset
|
1095 |
} |
1 | 1096 |
virtual int Opcode() const; |
1097 |
virtual const Type *bottom_type() const { return Type::MEMORY; } |
|
1098 |
// ClearArray modifies array elements, and so affects only the |
|
1099 |
// array memory addressed by the bottom_type of its base address. |
|
1100 |
virtual const class TypePtr *adr_type() const; |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
1101 |
virtual Node* Identity(PhaseGVN* phase); |
1 | 1102 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
1103 |
virtual uint match_edge(uint idx) const; |
|
36554
a7eb9ee4680c
8146801: Allocating short arrays of non-constant size is slow
shade
parents:
36316
diff
changeset
|
1104 |
bool is_large() const { return _is_large; } |
1 | 1105 |
|
1106 |
// Clear the given area of an object or array. |
|
1107 |
// The start offset must always be aligned mod BytesPerInt. |
|
1108 |
// The end offset must always be aligned mod BytesPerLong. |
|
1109 |
// Return the new memory. |
|
1110 |
static Node* clear_memory(Node* control, Node* mem, Node* dest, |
|
1111 |
intptr_t start_offset, |
|
1112 |
intptr_t end_offset, |
|
1113 |
PhaseGVN* phase); |
|
1114 |
static Node* clear_memory(Node* control, Node* mem, Node* dest, |
|
1115 |
intptr_t start_offset, |
|
1116 |
Node* end_offset, |
|
1117 |
PhaseGVN* phase); |
|
1118 |
static Node* clear_memory(Node* control, Node* mem, Node* dest, |
|
1119 |
Node* start_offset, |
|
1120 |
Node* end_offset, |
|
1121 |
PhaseGVN* phase); |
|
4470
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
3905
diff
changeset
|
1122 |
// Return allocation input memory edge if it is different instance |
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
3905
diff
changeset
|
1123 |
// or itself if it is the one we are looking for. |
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
3905
diff
changeset
|
1124 |
static bool step_through(Node** np, uint instance_id, PhaseTransform* phase); |
1 | 1125 |
}; |
1126 |
||
1127 |
//------------------------------MemBar----------------------------------------- |
|
1128 |
// There are different flavors of Memory Barriers to match the Java Memory |
|
1129 |
// Model. Monitor-enter and volatile-load act as Aquires: no following ref |
|
1130 |
// can be moved to before them. We insert a MemBar-Acquire after a FastLock or |
|
1131 |
// volatile-load. Monitor-exit and volatile-store act as Release: no |
|
2131 | 1132 |
// preceding ref can be moved to after them. We insert a MemBar-Release |
1 | 1133 |
// before a FastUnlock or volatile-store. All volatiles need to be |
1134 |
// serialized, so we follow all volatile-stores with a MemBar-Volatile to |
|
2131 | 1135 |
// separate it from any following volatile-load. |
1 | 1136 |
class MemBarNode: public MultiNode { |
1137 |
virtual uint hash() const ; // { return NO_HASH; } |
|
1138 |
virtual uint cmp( const Node &n ) const ; // Always fail, except on self |
|
1139 |
||
1140 |
virtual uint size_of() const { return sizeof(*this); } |
|
1141 |
// Memory type this node is serializing. Usually either rawptr or bottom. |
|
1142 |
const TypePtr* _adr_type; |
|
1143 |
||
1144 |
public: |
|
1145 |
enum { |
|
1146 |
Precedent = TypeFunc::Parms // optional edge to force precedence |
|
1147 |
}; |
|
1148 |
MemBarNode(Compile* C, int alias_idx, Node* precedent); |
|
1149 |
virtual int Opcode() const = 0; |
|
1150 |
virtual const class TypePtr *adr_type() const { return _adr_type; } |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
1151 |
virtual const Type* Value(PhaseGVN* phase) const; |
1 | 1152 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
1153 |
virtual uint match_edge(uint idx) const { return 0; } |
|
1154 |
virtual const Type *bottom_type() const { return TypeTuple::MEMBAR; } |
|
1155 |
virtual Node *match( const ProjNode *proj, const Matcher *m ); |
|
1156 |
// Factory method. Builds a wide or narrow membar. |
|
1157 |
// Optional 'precedent' becomes an extra edge if not null. |
|
1158 |
static MemBarNode* make(Compile* C, int opcode, |
|
1159 |
int alias_idx = Compile::AliasIdxBot, |
|
1160 |
Node* precedent = NULL); |
|
1161 |
}; |
|
1162 |
||
1163 |
// "Acquire" - no following ref can move before (but earlier refs can |
|
1164 |
// follow, like an early Load stalled in cache). Requires multi-cpu |
|
10262
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1165 |
// visibility. Inserted after a volatile load. |
1 | 1166 |
class MemBarAcquireNode: public MemBarNode { |
1167 |
public: |
|
1168 |
MemBarAcquireNode(Compile* C, int alias_idx, Node* precedent) |
|
1169 |
: MemBarNode(C, alias_idx, precedent) {} |
|
1170 |
virtual int Opcode() const; |
|
1171 |
}; |
|
1172 |
||
22855
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1173 |
// "Acquire" - no following ref can move before (but earlier refs can |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1174 |
// follow, like an early Load stalled in cache). Requires multi-cpu |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1175 |
// visibility. Inserted independ of any load, as required |
33606 | 1176 |
// for intrinsic Unsafe.loadFence(). |
22855
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1177 |
class LoadFenceNode: public MemBarNode { |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1178 |
public: |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1179 |
LoadFenceNode(Compile* C, int alias_idx, Node* precedent) |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1180 |
: MemBarNode(C, alias_idx, precedent) {} |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1181 |
virtual int Opcode() const; |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1182 |
}; |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1183 |
|
1 | 1184 |
// "Release" - no earlier ref can move after (but later refs can move |
1185 |
// up, like a speculative pipelined cache-hitting Load). Requires |
|
10262
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1186 |
// multi-cpu visibility. Inserted before a volatile store. |
1 | 1187 |
class MemBarReleaseNode: public MemBarNode { |
1188 |
public: |
|
1189 |
MemBarReleaseNode(Compile* C, int alias_idx, Node* precedent) |
|
1190 |
: MemBarNode(C, alias_idx, precedent) {} |
|
1191 |
virtual int Opcode() const; |
|
1192 |
}; |
|
1193 |
||
22855
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1194 |
// "Release" - no earlier ref can move after (but later refs can move |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1195 |
// up, like a speculative pipelined cache-hitting Load). Requires |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1196 |
// multi-cpu visibility. Inserted independent of any store, as required |
33606 | 1197 |
// for intrinsic Unsafe.storeFence(). |
22855
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1198 |
class StoreFenceNode: public MemBarNode { |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1199 |
public: |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1200 |
StoreFenceNode(Compile* C, int alias_idx, Node* precedent) |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1201 |
: MemBarNode(C, alias_idx, precedent) {} |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1202 |
virtual int Opcode() const; |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1203 |
}; |
d637fd28a6c3
8028515: PPPC64 (part 113.2): opto: Introduce LoadFence/StoreFence.
goetz
parents:
22851
diff
changeset
|
1204 |
|
10262
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1205 |
// "Acquire" - no following ref can move before (but earlier refs can |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1206 |
// follow, like an early Load stalled in cache). Requires multi-cpu |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1207 |
// visibility. Inserted after a FastLock. |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1208 |
class MemBarAcquireLockNode: public MemBarNode { |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1209 |
public: |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1210 |
MemBarAcquireLockNode(Compile* C, int alias_idx, Node* precedent) |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1211 |
: MemBarNode(C, alias_idx, precedent) {} |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1212 |
virtual int Opcode() const; |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1213 |
}; |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1214 |
|
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1215 |
// "Release" - no earlier ref can move after (but later refs can move |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1216 |
// up, like a speculative pipelined cache-hitting Load). Requires |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1217 |
// multi-cpu visibility. Inserted before a FastUnLock. |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1218 |
class MemBarReleaseLockNode: public MemBarNode { |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1219 |
public: |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1220 |
MemBarReleaseLockNode(Compile* C, int alias_idx, Node* precedent) |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1221 |
: MemBarNode(C, alias_idx, precedent) {} |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1222 |
virtual int Opcode() const; |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1223 |
}; |
c5f62d314bee
7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents:
8921
diff
changeset
|
1224 |
|
11431
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1225 |
class MemBarStoreStoreNode: public MemBarNode { |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1226 |
public: |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1227 |
MemBarStoreStoreNode(Compile* C, int alias_idx, Node* precedent) |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1228 |
: MemBarNode(C, alias_idx, precedent) { |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1229 |
init_class_id(Class_MemBarStoreStore); |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1230 |
} |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1231 |
virtual int Opcode() const; |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1232 |
}; |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1233 |
|
1 | 1234 |
// Ordering between a volatile store and a following volatile load. |
1235 |
// Requires multi-CPU visibility? |
|
1236 |
class MemBarVolatileNode: public MemBarNode { |
|
1237 |
public: |
|
1238 |
MemBarVolatileNode(Compile* C, int alias_idx, Node* precedent) |
|
1239 |
: MemBarNode(C, alias_idx, precedent) {} |
|
1240 |
virtual int Opcode() const; |
|
1241 |
}; |
|
1242 |
||
1243 |
// Ordering within the same CPU. Used to order unsafe memory references |
|
1244 |
// inside the compiler when we lack alias info. Not needed "outside" the |
|
1245 |
// compiler because the CPU does all the ordering for us. |
|
1246 |
class MemBarCPUOrderNode: public MemBarNode { |
|
1247 |
public: |
|
1248 |
MemBarCPUOrderNode(Compile* C, int alias_idx, Node* precedent) |
|
1249 |
: MemBarNode(C, alias_idx, precedent) {} |
|
1250 |
virtual int Opcode() const; |
|
1251 |
virtual uint ideal_reg() const { return 0; } // not matched in the AD file |
|
1252 |
}; |
|
1253 |
||
38017
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1254 |
class OnSpinWaitNode: public MemBarNode { |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1255 |
public: |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1256 |
OnSpinWaitNode(Compile* C, int alias_idx, Node* precedent) |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1257 |
: MemBarNode(C, alias_idx, precedent) {} |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1258 |
virtual int Opcode() const; |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1259 |
}; |
55047d16f141
8147844: new method j.l.Runtime.onSpinWait() and the corresponding x86 hotspot instrinsic
ikrylov
parents:
36831
diff
changeset
|
1260 |
|
1 | 1261 |
// Isolation of object setup after an AllocateNode and before next safepoint. |
1262 |
// (See comment in memnode.cpp near InitializeNode::InitializeNode for semantics.) |
|
1263 |
class InitializeNode: public MemBarNode { |
|
1264 |
friend class AllocateNode; |
|
1265 |
||
10566
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1266 |
enum { |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1267 |
Incomplete = 0, |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1268 |
Complete = 1, |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1269 |
WithArraycopy = 2 |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1270 |
}; |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1271 |
int _is_complete; |
1 | 1272 |
|
11431
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1273 |
bool _does_not_escape; |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1274 |
|
1 | 1275 |
public: |
1276 |
enum { |
|
1277 |
Control = TypeFunc::Control, |
|
1278 |
Memory = TypeFunc::Memory, // MergeMem for states affected by this op |
|
1279 |
RawAddress = TypeFunc::Parms+0, // the newly-allocated raw address |
|
1280 |
RawStores = TypeFunc::Parms+1 // zero or more stores (or TOP) |
|
1281 |
}; |
|
1282 |
||
1283 |
InitializeNode(Compile* C, int adr_type, Node* rawoop); |
|
1284 |
virtual int Opcode() const; |
|
1285 |
virtual uint size_of() const { return sizeof(*this); } |
|
1286 |
virtual uint ideal_reg() const { return 0; } // not matched in the AD file |
|
1287 |
virtual const RegMask &in_RegMask(uint) const; // mask for RawAddress |
|
1288 |
||
1289 |
// Manage incoming memory edges via a MergeMem on in(Memory): |
|
1290 |
Node* memory(uint alias_idx); |
|
1291 |
||
1292 |
// The raw memory edge coming directly from the Allocation. |
|
1293 |
// The contents of this memory are *always* all-zero-bits. |
|
1294 |
Node* zero_memory() { return memory(Compile::AliasIdxRaw); } |
|
1295 |
||
1296 |
// Return the corresponding allocation for this initialization (or null if none). |
|
1297 |
// (Note: Both InitializeNode::allocation and AllocateNode::initialization |
|
1298 |
// are defined in graphKit.cpp, which sets up the bidirectional relation.) |
|
1299 |
AllocateNode* allocation(); |
|
1300 |
||
1301 |
// Anything other than zeroing in this init? |
|
1302 |
bool is_non_zero(); |
|
1303 |
||
1304 |
// An InitializeNode must completed before macro expansion is done. |
|
1305 |
// Completion requires that the AllocateNode must be followed by |
|
1306 |
// initialization of the new memory to zero, then to any initializers. |
|
10566
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1307 |
bool is_complete() { return _is_complete != Incomplete; } |
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1308 |
bool is_complete_with_arraycopy() { return (_is_complete & WithArraycopy) != 0; } |
1 | 1309 |
|
1310 |
// Mark complete. (Must not yet be complete.) |
|
1311 |
void set_complete(PhaseGVN* phase); |
|
10566
630c177ec580
7081933: Use zeroing elimination optimization for large array
kvn
parents:
10267
diff
changeset
|
1312 |
void set_complete_with_arraycopy() { _is_complete = Complete | WithArraycopy; } |
1 | 1313 |
|
11431
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1314 |
bool does_not_escape() { return _does_not_escape; } |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1315 |
void set_does_not_escape() { _does_not_escape = true; } |
5ca3a19e559a
7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents:
11191
diff
changeset
|
1316 |
|
1 | 1317 |
#ifdef ASSERT |
1318 |
// ensure all non-degenerate stores are ordered and non-overlapping |
|
1319 |
bool stores_are_sane(PhaseTransform* phase); |
|
1320 |
#endif //ASSERT |
|
1321 |
||
1322 |
// See if this store can be captured; return offset where it initializes. |
|
1323 |
// Return 0 if the store cannot be moved (any sort of problem). |
|
15813
6efd4c793e47
8007294: ReduceFieldZeroing doesn't check for dependent load and can lead to incorrect execution
roland
parents:
15242
diff
changeset
|
1324 |
intptr_t can_capture_store(StoreNode* st, PhaseTransform* phase, bool can_reshape); |
1 | 1325 |
|
1326 |
// Capture another store; reformat it to write my internal raw memory. |
|
1327 |
// Return the captured copy, else NULL if there is some sort of problem. |
|
15813
6efd4c793e47
8007294: ReduceFieldZeroing doesn't check for dependent load and can lead to incorrect execution
roland
parents:
15242
diff
changeset
|
1328 |
Node* capture_store(StoreNode* st, intptr_t start, PhaseTransform* phase, bool can_reshape); |
1 | 1329 |
|
1330 |
// Find captured store which corresponds to the range [start..start+size). |
|
1331 |
// Return my own memory projection (meaning the initial zero bits) |
|
1332 |
// if there is no such store. Return NULL if there is a problem. |
|
1333 |
Node* find_captured_store(intptr_t start, int size_in_bytes, PhaseTransform* phase); |
|
1334 |
||
1335 |
// Called when the associated AllocateNode is expanded into CFG. |
|
1336 |
Node* complete_stores(Node* rawctl, Node* rawmem, Node* rawptr, |
|
1337 |
intptr_t header_size, Node* size_in_bytes, |
|
1338 |
PhaseGVN* phase); |
|
1339 |
||
1340 |
private: |
|
1341 |
void remove_extra_zeroes(); |
|
1342 |
||
1343 |
// Find out where a captured store should be placed (or already is placed). |
|
1344 |
int captured_store_insertion_point(intptr_t start, int size_in_bytes, |
|
1345 |
PhaseTransform* phase); |
|
1346 |
||
1347 |
static intptr_t get_store_offset(Node* st, PhaseTransform* phase); |
|
1348 |
||
1349 |
Node* make_raw_address(intptr_t offset, PhaseTransform* phase); |
|
1350 |
||
17383 | 1351 |
bool detect_init_independence(Node* n, int& count); |
1 | 1352 |
|
1353 |
void coalesce_subword_stores(intptr_t header_size, Node* size_in_bytes, |
|
1354 |
PhaseGVN* phase); |
|
1355 |
||
1356 |
intptr_t find_next_fullword_store(uint i, PhaseGVN* phase); |
|
1357 |
}; |
|
1358 |
||
1359 |
//------------------------------MergeMem--------------------------------------- |
|
1360 |
// (See comment in memnode.cpp near MergeMemNode::MergeMemNode for semantics.) |
|
1361 |
class MergeMemNode: public Node { |
|
1362 |
virtual uint hash() const ; // { return NO_HASH; } |
|
1363 |
virtual uint cmp( const Node &n ) const ; // Always fail, except on self |
|
1364 |
friend class MergeMemStream; |
|
1365 |
MergeMemNode(Node* def); // clients use MergeMemNode::make |
|
1366 |
||
1367 |
public: |
|
1368 |
// If the input is a whole memory state, clone it with all its slices intact. |
|
1369 |
// Otherwise, make a new memory state with just that base memory input. |
|
1370 |
// In either case, the result is a newly created MergeMem. |
|
25930 | 1371 |
static MergeMemNode* make(Node* base_memory); |
1 | 1372 |
|
1373 |
virtual int Opcode() const; |
|
35551
36ef3841fb34
8146629: Make phase->is_IterGVN() accessible from Node::Identity and Node::Value
thartmann
parents:
34189
diff
changeset
|
1374 |
virtual Node* Identity(PhaseGVN* phase); |
1 | 1375 |
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
1376 |
virtual uint ideal_reg() const { return NotAMachineReg; } |
|
1377 |
virtual uint match_edge(uint idx) const { return 0; } |
|
1378 |
virtual const RegMask &out_RegMask() const; |
|
1379 |
virtual const Type *bottom_type() const { return Type::MEMORY; } |
|
1380 |
virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; } |
|
1381 |
// sparse accessors |
|
1382 |
// Fetch the previously stored "set_memory_at", or else the base memory. |
|
1383 |
// (Caller should clone it if it is a phi-nest.) |
|
1384 |
Node* memory_at(uint alias_idx) const; |
|
1385 |
// set the memory, regardless of its previous value |
|
1386 |
void set_memory_at(uint alias_idx, Node* n); |
|
1387 |
// the "base" is the memory that provides the non-finite support |
|
1388 |
Node* base_memory() const { return in(Compile::AliasIdxBot); } |
|
1389 |
// warning: setting the base can implicitly set any of the other slices too |
|
1390 |
void set_base_memory(Node* def); |
|
1391 |
// sentinel value which denotes a copy of the base memory: |
|
1392 |
Node* empty_memory() const { return in(Compile::AliasIdxTop); } |
|
1393 |
static Node* make_empty_memory(); // where the sentinel comes from |
|
1394 |
bool is_empty_memory(Node* n) const { assert((n == empty_memory()) == n->is_top(), "sanity"); return n->is_top(); } |
|
1395 |
// hook for the iterator, to perform any necessary setup |
|
1396 |
void iteration_setup(const MergeMemNode* other = NULL); |
|
1397 |
// push sentinels until I am at least as long as the other (semantic no-op) |
|
1398 |
void grow_to_match(const MergeMemNode* other); |
|
1399 |
bool verify_sparse() const PRODUCT_RETURN0; |
|
1400 |
#ifndef PRODUCT |
|
1401 |
virtual void dump_spec(outputStream *st) const; |
|
1402 |
#endif |
|
1403 |
}; |
|
1404 |
||
1405 |
class MergeMemStream : public StackObj { |
|
1406 |
private: |
|
1407 |
MergeMemNode* _mm; |
|
1408 |
const MergeMemNode* _mm2; // optional second guy, contributes non-empty iterations |
|
1409 |
Node* _mm_base; // loop-invariant base memory of _mm |
|
1410 |
int _idx; |
|
1411 |
int _cnt; |
|
1412 |
Node* _mem; |
|
1413 |
Node* _mem2; |
|
1414 |
int _cnt2; |
|
1415 |
||
1416 |
void init(MergeMemNode* mm, const MergeMemNode* mm2 = NULL) { |
|
1417 |
// subsume_node will break sparseness at times, whenever a memory slice |
|
1418 |
// folds down to a copy of the base ("fat") memory. In such a case, |
|
1419 |
// the raw edge will update to base, although it should be top. |
|
1420 |
// This iterator will recognize either top or base_memory as an |
|
1421 |
// "empty" slice. See is_empty, is_empty2, and next below. |
|
1422 |
// |
|
1423 |
// The sparseness property is repaired in MergeMemNode::Ideal. |
|
1424 |
// As long as access to a MergeMem goes through this iterator |
|
1425 |
// or the memory_at accessor, flaws in the sparseness will |
|
1426 |
// never be observed. |
|
1427 |
// |
|
1428 |
// Also, iteration_setup repairs sparseness. |
|
1429 |
assert(mm->verify_sparse(), "please, no dups of base"); |
|
1430 |
assert(mm2==NULL || mm2->verify_sparse(), "please, no dups of base"); |
|
1431 |
||
1432 |
_mm = mm; |
|
1433 |
_mm_base = mm->base_memory(); |
|
1434 |
_mm2 = mm2; |
|
1435 |
_cnt = mm->req(); |
|
1436 |
_idx = Compile::AliasIdxBot-1; // start at the base memory |
|
1437 |
_mem = NULL; |
|
1438 |
_mem2 = NULL; |
|
1439 |
} |
|
1440 |
||
1441 |
#ifdef ASSERT |
|
1442 |
Node* check_memory() const { |
|
1443 |
if (at_base_memory()) |
|
1444 |
return _mm->base_memory(); |
|
1445 |
else if ((uint)_idx < _mm->req() && !_mm->in(_idx)->is_top()) |
|
1446 |
return _mm->memory_at(_idx); |
|
1447 |
else |
|
1448 |
return _mm_base; |
|
1449 |
} |
|
1450 |
Node* check_memory2() const { |
|
1451 |
return at_base_memory()? _mm2->base_memory(): _mm2->memory_at(_idx); |
|
1452 |
} |
|
1453 |
#endif |
|
1454 |
||
1455 |
static bool match_memory(Node* mem, const MergeMemNode* mm, int idx) PRODUCT_RETURN0; |
|
1456 |
void assert_synch() const { |
|
1457 |
assert(!_mem || _idx >= _cnt || match_memory(_mem, _mm, _idx), |
|
1458 |
"no side-effects except through the stream"); |
|
1459 |
} |
|
1460 |
||
1461 |
public: |
|
1462 |
||
1463 |
// expected usages: |
|
1464 |
// for (MergeMemStream mms(mem->is_MergeMem()); next_non_empty(); ) { ... } |
|
1465 |
// for (MergeMemStream mms(mem1, mem2); next_non_empty2(); ) { ... } |
|
1466 |
||
1467 |
// iterate over one merge |
|
1468 |
MergeMemStream(MergeMemNode* mm) { |
|
1469 |
mm->iteration_setup(); |
|
1470 |
init(mm); |
|
1471 |
debug_only(_cnt2 = 999); |
|
1472 |
} |
|
1473 |
// iterate in parallel over two merges |
|
1474 |
// only iterates through non-empty elements of mm2 |
|
1475 |
MergeMemStream(MergeMemNode* mm, const MergeMemNode* mm2) { |
|
1476 |
assert(mm2, "second argument must be a MergeMem also"); |
|
1477 |
((MergeMemNode*)mm2)->iteration_setup(); // update hidden state |
|
1478 |
mm->iteration_setup(mm2); |
|
1479 |
init(mm, mm2); |
|
1480 |
_cnt2 = mm2->req(); |
|
1481 |
} |
|
1482 |
#ifdef ASSERT |
|
1483 |
~MergeMemStream() { |
|
1484 |
assert_synch(); |
|
1485 |
} |
|
1486 |
#endif |
|
1487 |
||
1488 |
MergeMemNode* all_memory() const { |
|
1489 |
return _mm; |
|
1490 |
} |
|
1491 |
Node* base_memory() const { |
|
1492 |
assert(_mm_base == _mm->base_memory(), "no update to base memory, please"); |
|
1493 |
return _mm_base; |
|
1494 |
} |
|
1495 |
const MergeMemNode* all_memory2() const { |
|
1496 |
assert(_mm2 != NULL, ""); |
|
1497 |
return _mm2; |
|
1498 |
} |
|
1499 |
bool at_base_memory() const { |
|
1500 |
return _idx == Compile::AliasIdxBot; |
|
1501 |
} |
|
1502 |
int alias_idx() const { |
|
1503 |
assert(_mem, "must call next 1st"); |
|
1504 |
return _idx; |
|
1505 |
} |
|
1506 |
||
1507 |
const TypePtr* adr_type() const { |
|
1508 |
return Compile::current()->get_adr_type(alias_idx()); |
|
1509 |
} |
|
1510 |
||
1511 |
const TypePtr* adr_type(Compile* C) const { |
|
1512 |
return C->get_adr_type(alias_idx()); |
|
1513 |
} |
|
1514 |
bool is_empty() const { |
|
1515 |
assert(_mem, "must call next 1st"); |
|
1516 |
assert(_mem->is_top() == (_mem==_mm->empty_memory()), "correct sentinel"); |
|
1517 |
return _mem->is_top(); |
|
1518 |
} |
|
1519 |
bool is_empty2() const { |
|
1520 |
assert(_mem2, "must call next 1st"); |
|
1521 |
assert(_mem2->is_top() == (_mem2==_mm2->empty_memory()), "correct sentinel"); |
|
1522 |
return _mem2->is_top(); |
|
1523 |
} |
|
1524 |
Node* memory() const { |
|
1525 |
assert(!is_empty(), "must not be empty"); |
|
1526 |
assert_synch(); |
|
1527 |
return _mem; |
|
1528 |
} |
|
1529 |
// get the current memory, regardless of empty or non-empty status |
|
1530 |
Node* force_memory() const { |
|
1531 |
assert(!is_empty() || !at_base_memory(), ""); |
|
1532 |
// Use _mm_base to defend against updates to _mem->base_memory(). |
|
1533 |
Node *mem = _mem->is_top() ? _mm_base : _mem; |
|
1534 |
assert(mem == check_memory(), ""); |
|
1535 |
return mem; |
|
1536 |
} |
|
1537 |
Node* memory2() const { |
|
1538 |
assert(_mem2 == check_memory2(), ""); |
|
1539 |
return _mem2; |
|
1540 |
} |
|
1541 |
void set_memory(Node* mem) { |
|
1542 |
if (at_base_memory()) { |
|
1543 |
// Note that this does not change the invariant _mm_base. |
|
1544 |
_mm->set_base_memory(mem); |
|
1545 |
} else { |
|
1546 |
_mm->set_memory_at(_idx, mem); |
|
1547 |
} |
|
1548 |
_mem = mem; |
|
1549 |
assert_synch(); |
|
1550 |
} |
|
1551 |
||
1552 |
// Recover from a side effect to the MergeMemNode. |
|
1553 |
void set_memory() { |
|
1554 |
_mem = _mm->in(_idx); |
|
1555 |
} |
|
1556 |
||
1557 |
bool next() { return next(false); } |
|
1558 |
bool next2() { return next(true); } |
|
1559 |
||
1560 |
bool next_non_empty() { return next_non_empty(false); } |
|
1561 |
bool next_non_empty2() { return next_non_empty(true); } |
|
1562 |
// next_non_empty2 can yield states where is_empty() is true |
|
1563 |
||
1564 |
private: |
|
1565 |
// find the next item, which might be empty |
|
1566 |
bool next(bool have_mm2) { |
|
1567 |
assert((_mm2 != NULL) == have_mm2, "use other next"); |
|
1568 |
assert_synch(); |
|
1569 |
if (++_idx < _cnt) { |
|
1570 |
// Note: This iterator allows _mm to be non-sparse. |
|
1571 |
// It behaves the same whether _mem is top or base_memory. |
|
1572 |
_mem = _mm->in(_idx); |
|
1573 |
if (have_mm2) |
|
1574 |
_mem2 = _mm2->in((_idx < _cnt2) ? _idx : Compile::AliasIdxTop); |
|
1575 |
return true; |
|
1576 |
} |
|
1577 |
return false; |
|
1578 |
} |
|
1579 |
||
1580 |
// find the next non-empty item |
|
1581 |
bool next_non_empty(bool have_mm2) { |
|
1582 |
while (next(have_mm2)) { |
|
1583 |
if (!is_empty()) { |
|
1584 |
// make sure _mem2 is filled in sensibly |
|
1585 |
if (have_mm2 && _mem2->is_top()) _mem2 = _mm2->base_memory(); |
|
1586 |
return true; |
|
1587 |
} else if (have_mm2 && !is_empty2()) { |
|
1588 |
return true; // is_empty() == true |
|
1589 |
} |
|
1590 |
} |
|
1591 |
return false; |
|
1592 |
} |
|
1593 |
}; |
|
1594 |
||
1595 |
//------------------------------Prefetch--------------------------------------- |
|
1596 |
||
10267 | 1597 |
// Allocation prefetch which may fault, TLAB size have to be adjusted. |
1598 |
class PrefetchAllocationNode : public Node { |
|
1599 |
public: |
|
1600 |
PrefetchAllocationNode(Node *mem, Node *adr) : Node(0,mem,adr) {} |
|
1601 |
virtual int Opcode() const; |
|
1602 |
virtual uint ideal_reg() const { return NotAMachineReg; } |
|
1603 |
virtual uint match_edge(uint idx) const { return idx==2; } |
|
5251
f86f7a86d761
6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents:
4746
diff
changeset
|
1604 |
virtual const Type *bottom_type() const { return ( AllocatePrefetchStyle == 3 ) ? Type::MEMORY : Type::ABIO; } |
1 | 1605 |
}; |
7397 | 1606 |
|
1607 |
#endif // SHARE_VM_OPTO_MEMNODE_HPP |