Mercurial > hg > truffle
annotate src/share/vm/opto/callnode.hpp @ 10278:6f3fd5150b67
6934604: enable parts of EliminateAutoBox by default
Summary: Resurrected autobox elimination code and enabled part of it by default.
Reviewed-by: roland, twisti
| author | kvn |
|---|---|
| date | Wed, 08 May 2013 15:08:01 -0700 |
| parents | a7114d3d712e |
| children | 9758d9f36299 766fac3395d6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
5948
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1137
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1137
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1137
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_CALLNODE_HPP |
| 26 #define SHARE_VM_OPTO_CALLNODE_HPP | |
| 27 | |
| 28 #include "opto/connode.hpp" | |
| 29 #include "opto/mulnode.hpp" | |
| 30 #include "opto/multnode.hpp" | |
| 31 #include "opto/opcodes.hpp" | |
| 32 #include "opto/phaseX.hpp" | |
| 33 #include "opto/type.hpp" | |
| 34 | |
| 0 | 35 // Portions of code courtesy of Clifford Click |
| 36 | |
| 37 // Optimization - Graph Style | |
| 38 | |
| 39 class Chaitin; | |
| 40 class NamedCounter; | |
| 41 class MultiNode; | |
| 42 class SafePointNode; | |
| 43 class CallNode; | |
| 44 class CallJavaNode; | |
| 45 class CallStaticJavaNode; | |
| 46 class CallDynamicJavaNode; | |
| 47 class CallRuntimeNode; | |
| 48 class CallLeafNode; | |
| 49 class CallLeafNoFPNode; | |
| 50 class AllocateNode; | |
| 33 | 51 class AllocateArrayNode; |
| 10278 | 52 class BoxLockNode; |
| 0 | 53 class LockNode; |
| 54 class UnlockNode; | |
| 55 class JVMState; | |
| 56 class OopMap; | |
| 57 class State; | |
| 58 class StartNode; | |
| 59 class MachCallNode; | |
| 60 class FastLockNode; | |
| 61 | |
| 62 //------------------------------StartNode-------------------------------------- | |
| 63 // The method start node | |
| 64 class StartNode : public MultiNode { | |
| 65 virtual uint cmp( const Node &n ) const; | |
| 66 virtual uint size_of() const; // Size is bigger | |
| 67 public: | |
| 68 const TypeTuple *_domain; | |
| 69 StartNode( Node *root, const TypeTuple *domain ) : MultiNode(2), _domain(domain) { | |
| 70 init_class_id(Class_Start); | |
| 71 init_req(0,this); | |
| 72 init_req(1,root); | |
| 73 } | |
| 74 virtual int Opcode() const; | |
| 75 virtual bool pinned() const { return true; }; | |
| 76 virtual const Type *bottom_type() const; | |
| 77 virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; } | |
| 78 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 79 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 80 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_reg, uint length ) const; | |
| 81 virtual const RegMask &in_RegMask(uint) const; | |
| 82 virtual Node *match( const ProjNode *proj, const Matcher *m ); | |
| 83 virtual uint ideal_reg() const { return 0; } | |
| 84 #ifndef PRODUCT | |
| 85 virtual void dump_spec(outputStream *st) const; | |
| 86 #endif | |
| 87 }; | |
| 88 | |
| 89 //------------------------------StartOSRNode----------------------------------- | |
| 90 // The method start node for on stack replacement code | |
| 91 class StartOSRNode : public StartNode { | |
| 92 public: | |
| 93 StartOSRNode( Node *root, const TypeTuple *domain ) : StartNode(root, domain) {} | |
| 94 virtual int Opcode() const; | |
| 95 static const TypeTuple *osr_domain(); | |
| 96 }; | |
| 97 | |
| 98 | |
| 99 //------------------------------ParmNode--------------------------------------- | |
| 100 // Incoming parameters | |
| 101 class ParmNode : public ProjNode { | |
| 102 static const char * const names[TypeFunc::Parms+1]; | |
| 103 public: | |
| 33 | 104 ParmNode( StartNode *src, uint con ) : ProjNode(src,con) { |
| 105 init_class_id(Class_Parm); | |
| 106 } | |
| 0 | 107 virtual int Opcode() const; |
| 108 virtual bool is_CFG() const { return (_con == TypeFunc::Control); } | |
| 109 virtual uint ideal_reg() const; | |
| 110 #ifndef PRODUCT | |
| 111 virtual void dump_spec(outputStream *st) const; | |
| 112 #endif | |
| 113 }; | |
| 114 | |
| 115 | |
| 116 //------------------------------ReturnNode------------------------------------- | |
| 117 // Return from subroutine node | |
| 118 class ReturnNode : public Node { | |
| 119 public: | |
| 120 ReturnNode( uint edges, Node *cntrl, Node *i_o, Node *memory, Node *retadr, Node *frameptr ); | |
| 121 virtual int Opcode() const; | |
| 122 virtual bool is_CFG() const { return true; } | |
| 123 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash | |
| 124 virtual bool depends_only_on_test() const { return false; } | |
| 125 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 126 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 127 virtual uint ideal_reg() const { return NotAMachineReg; } | |
| 128 virtual uint match_edge(uint idx) const; | |
| 129 #ifndef PRODUCT | |
|
7636
a7114d3d712e
8005055: pass outputStream to more opto debug routines
kvn
parents:
7473
diff
changeset
|
130 virtual void dump_req(outputStream *st = tty) const; |
| 0 | 131 #endif |
| 132 }; | |
| 133 | |
| 134 | |
| 135 //------------------------------RethrowNode------------------------------------ | |
| 136 // Rethrow of exception at call site. Ends a procedure before rethrowing; | |
| 137 // ends the current basic block like a ReturnNode. Restores registers and | |
| 138 // unwinds stack. Rethrow happens in the caller's method. | |
| 139 class RethrowNode : public Node { | |
| 140 public: | |
| 141 RethrowNode( Node *cntrl, Node *i_o, Node *memory, Node *frameptr, Node *ret_adr, Node *exception ); | |
| 142 virtual int Opcode() const; | |
| 143 virtual bool is_CFG() const { return true; } | |
| 144 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash | |
| 145 virtual bool depends_only_on_test() const { return false; } | |
| 146 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 147 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 148 virtual uint match_edge(uint idx) const; | |
| 149 virtual uint ideal_reg() const { return NotAMachineReg; } | |
| 150 #ifndef PRODUCT | |
|
7636
a7114d3d712e
8005055: pass outputStream to more opto debug routines
kvn
parents:
7473
diff
changeset
|
151 virtual void dump_req(outputStream *st = tty) const; |
| 0 | 152 #endif |
| 153 }; | |
| 154 | |
| 155 | |
| 156 //------------------------------TailCallNode----------------------------------- | |
| 157 // Pop stack frame and jump indirect | |
| 158 class TailCallNode : public ReturnNode { | |
| 159 public: | |
| 160 TailCallNode( Node *cntrl, Node *i_o, Node *memory, Node *frameptr, Node *retadr, Node *target, Node *moop ) | |
| 161 : ReturnNode( TypeFunc::Parms+2, cntrl, i_o, memory, frameptr, retadr ) { | |
| 162 init_req(TypeFunc::Parms, target); | |
| 163 init_req(TypeFunc::Parms+1, moop); | |
| 164 } | |
| 165 | |
| 166 virtual int Opcode() const; | |
| 167 virtual uint match_edge(uint idx) const; | |
| 168 }; | |
| 169 | |
| 170 //------------------------------TailJumpNode----------------------------------- | |
| 171 // Pop stack frame and jump indirect | |
| 172 class TailJumpNode : public ReturnNode { | |
| 173 public: | |
| 174 TailJumpNode( Node *cntrl, Node *i_o, Node *memory, Node *frameptr, Node *target, Node *ex_oop) | |
| 175 : ReturnNode(TypeFunc::Parms+2, cntrl, i_o, memory, frameptr, Compile::current()->top()) { | |
| 176 init_req(TypeFunc::Parms, target); | |
| 177 init_req(TypeFunc::Parms+1, ex_oop); | |
| 178 } | |
| 179 | |
| 180 virtual int Opcode() const; | |
| 181 virtual uint match_edge(uint idx) const; | |
| 182 }; | |
| 183 | |
| 184 //-------------------------------JVMState------------------------------------- | |
| 185 // A linked list of JVMState nodes captures the whole interpreter state, | |
| 186 // plus GC roots, for all active calls at some call site in this compilation | |
| 187 // unit. (If there is no inlining, then the list has exactly one link.) | |
| 188 // This provides a way to map the optimized program back into the interpreter, | |
| 189 // or to let the GC mark the stack. | |
| 190 class JVMState : public ResourceObj { | |
| 3939 | 191 friend class VMStructs; |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
192 public: |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
193 typedef enum { |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
194 Reexecute_Undefined = -1, // not defined -- will be translated into false later |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
195 Reexecute_False = 0, // false -- do not reexecute |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
196 Reexecute_True = 1 // true -- reexecute the bytecode |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
197 } ReexecuteState; //Reexecute State |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
198 |
| 0 | 199 private: |
| 200 JVMState* _caller; // List pointer for forming scope chains | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
201 uint _depth; // One more than caller depth, or one. |
| 0 | 202 uint _locoff; // Offset to locals in input edge mapping |
| 203 uint _stkoff; // Offset to stack in input edge mapping | |
| 204 uint _monoff; // Offset to monitors in input edge mapping | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
205 uint _scloff; // Offset to fields of scalar objs in input edge mapping |
| 0 | 206 uint _endoff; // Offset to end of input edge mapping |
| 207 uint _sp; // Jave Expression Stack Pointer for this state | |
| 208 int _bci; // Byte Code Index of this JVM point | |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
209 ReexecuteState _reexecute; // Whether this bytecode need to be re-executed |
| 0 | 210 ciMethod* _method; // Method Pointer |
| 211 SafePointNode* _map; // Map node associated with this scope | |
| 212 public: | |
| 213 friend class Compile; | |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
214 friend class PreserveReexecuteState; |
| 0 | 215 |
| 216 // Because JVMState objects live over the entire lifetime of the | |
| 217 // Compile object, they are allocated into the comp_arena, which | |
| 218 // does not get resource marked or reset during the compile process | |
| 219 void *operator new( size_t x, Compile* C ) { return C->comp_arena()->Amalloc(x); } | |
| 220 void operator delete( void * ) { } // fast deallocation | |
| 221 | |
| 222 // Create a new JVMState, ready for abstract interpretation. | |
| 223 JVMState(ciMethod* method, JVMState* caller); | |
| 224 JVMState(int stack_size); // root state; has a null method | |
| 225 | |
| 226 // Access functions for the JVM | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
227 // ... --|--- loc ---|--- stk ---|--- arg ---|--- mon ---|--- scl ---| |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
228 // \ locoff \ stkoff \ argoff \ monoff \ scloff \ endoff |
| 0 | 229 uint locoff() const { return _locoff; } |
| 230 uint stkoff() const { return _stkoff; } | |
| 231 uint argoff() const { return _stkoff + _sp; } | |
| 232 uint monoff() const { return _monoff; } | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
233 uint scloff() const { return _scloff; } |
| 0 | 234 uint endoff() const { return _endoff; } |
| 235 uint oopoff() const { return debug_end(); } | |
| 236 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
237 int loc_size() const { return stkoff() - locoff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
238 int stk_size() const { return monoff() - stkoff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
239 int mon_size() const { return scloff() - monoff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
240 int scl_size() const { return endoff() - scloff(); } |
| 0 | 241 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
242 bool is_loc(uint i) const { return locoff() <= i && i < stkoff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
243 bool is_stk(uint i) const { return stkoff() <= i && i < monoff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
244 bool is_mon(uint i) const { return monoff() <= i && i < scloff(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5948
diff
changeset
|
245 bool is_scl(uint i) const { return scloff() <= i && i < endoff(); } |
| 0 | 246 |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
247 uint sp() const { return _sp; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
248 int bci() const { return _bci; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
249 bool should_reexecute() const { return _reexecute==Reexecute_True; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
250 bool is_reexecute_undefined() const { return _reexecute==Reexecute_Undefined; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
251 bool has_method() const { return _method != NULL; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
252 ciMethod* method() const { assert(has_method(), ""); return _method; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
253 JVMState* caller() const { return _caller; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
254 SafePointNode* map() const { return _map; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
255 uint depth() const { return _depth; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
256 uint debug_start() const; // returns locoff of root caller |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
257 uint debug_end() const; // returns endoff of self |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
258 uint debug_size() const { |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
259 return loc_size() + sp() + mon_size() + scl_size(); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
260 } |
| 0 | 261 uint debug_depth() const; // returns sum of debug_size values at all depths |
| 262 | |
| 263 // Returns the JVM state at the desired depth (1 == root). | |
| 264 JVMState* of_depth(int d) const; | |
| 265 | |
| 266 // Tells if two JVM states have the same call chain (depth, methods, & bcis). | |
| 267 bool same_calls_as(const JVMState* that) const; | |
| 268 | |
| 269 // Monitors (monitors are stored as (boxNode, objNode) pairs | |
| 270 enum { logMonitorEdges = 1 }; | |
| 271 int nof_monitors() const { return mon_size() >> logMonitorEdges; } | |
| 272 int monitor_depth() const { return nof_monitors() + (caller() ? caller()->monitor_depth() : 0); } | |
| 273 int monitor_box_offset(int idx) const { return monoff() + (idx << logMonitorEdges) + 0; } | |
| 274 int monitor_obj_offset(int idx) const { return monoff() + (idx << logMonitorEdges) + 1; } | |
| 275 bool is_monitor_box(uint off) const { | |
| 276 assert(is_mon(off), "should be called only for monitor edge"); | |
| 277 return (0 == bitfield(off - monoff(), 0, logMonitorEdges)); | |
| 278 } | |
| 279 bool is_monitor_use(uint off) const { return (is_mon(off) | |
| 280 && is_monitor_box(off)) | |
| 281 || (caller() && caller()->is_monitor_use(off)); } | |
| 282 | |
| 283 // Initialization functions for the JVM | |
| 284 void set_locoff(uint off) { _locoff = off; } | |
| 285 void set_stkoff(uint off) { _stkoff = off; } | |
| 286 void set_monoff(uint off) { _monoff = off; } | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
287 void set_scloff(uint off) { _scloff = off; } |
| 0 | 288 void set_endoff(uint off) { _endoff = off; } |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
289 void set_offsets(uint off) { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
290 _locoff = _stkoff = _monoff = _scloff = _endoff = off; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
291 } |
| 0 | 292 void set_map(SafePointNode *map) { _map = map; } |
| 293 void set_sp(uint sp) { _sp = sp; } | |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
294 // _reexecute is initialized to "undefined" for a new bci |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
295 void set_bci(int bci) {if(_bci != bci)_reexecute=Reexecute_Undefined; _bci = bci; } |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
704
diff
changeset
|
296 void set_should_reexecute(bool reexec) {_reexecute = reexec ? Reexecute_True : Reexecute_False;} |
| 0 | 297 |
| 298 // Miscellaneous utility functions | |
| 299 JVMState* clone_deep(Compile* C) const; // recursively clones caller chain | |
| 300 JVMState* clone_shallow(Compile* C) const; // retains uncloned caller | |
| 10278 | 301 void set_map_deep(SafePointNode *map);// reset map for all callers |
| 0 | 302 |
| 303 #ifndef PRODUCT | |
| 304 void format(PhaseRegAlloc *regalloc, const Node *n, outputStream* st) const; | |
| 305 void dump_spec(outputStream *st) const; | |
| 306 void dump_on(outputStream* st) const; | |
| 307 void dump() const { | |
| 308 dump_on(tty); | |
| 309 } | |
| 310 #endif | |
| 311 }; | |
| 312 | |
| 313 //------------------------------SafePointNode---------------------------------- | |
| 314 // A SafePointNode is a subclass of a MultiNode for convenience (and | |
| 315 // potential code sharing) only - conceptually it is independent of | |
| 316 // the Node semantics. | |
| 317 class SafePointNode : public MultiNode { | |
| 318 virtual uint cmp( const Node &n ) const; | |
| 319 virtual uint size_of() const; // Size is bigger | |
| 320 | |
| 321 public: | |
| 322 SafePointNode(uint edges, JVMState* jvms, | |
| 323 // A plain safepoint advertises no memory effects (NULL): | |
| 324 const TypePtr* adr_type = NULL) | |
| 325 : MultiNode( edges ), | |
| 326 _jvms(jvms), | |
| 327 _oop_map(NULL), | |
| 328 _adr_type(adr_type) | |
| 329 { | |
| 330 init_class_id(Class_SafePoint); | |
| 331 } | |
| 332 | |
| 333 OopMap* _oop_map; // Array of OopMap info (8-bit char) for GC | |
| 334 JVMState* const _jvms; // Pointer to list of JVM State objects | |
| 335 const TypePtr* _adr_type; // What type of memory does this node produce? | |
| 336 | |
| 337 // Many calls take *all* of memory as input, | |
| 338 // but some produce a limited subset of that memory as output. | |
| 339 // The adr_type reports the call's behavior as a store, not a load. | |
| 340 | |
| 341 virtual JVMState* jvms() const { return _jvms; } | |
| 342 void set_jvms(JVMState* s) { | |
| 343 *(JVMState**)&_jvms = s; // override const attribute in the accessor | |
| 344 } | |
| 345 OopMap *oop_map() const { return _oop_map; } | |
| 346 void set_oop_map(OopMap *om) { _oop_map = om; } | |
| 347 | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
348 private: |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
349 void verify_input(JVMState* jvms, uint idx) const { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
350 assert(verify_jvms(jvms), "jvms must match"); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
351 Node* n = in(idx); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
352 assert((!n->bottom_type()->isa_long() && !n->bottom_type()->isa_double()) || |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
353 in(idx + 1)->is_top(), "2nd half of long/double"); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
354 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
355 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
356 public: |
| 0 | 357 // Functionality from old debug nodes which has changed |
| 358 Node *local(JVMState* jvms, uint idx) const { | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
359 verify_input(jvms, jvms->locoff() + idx); |
| 0 | 360 return in(jvms->locoff() + idx); |
| 361 } | |
| 362 Node *stack(JVMState* jvms, uint idx) const { | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
363 verify_input(jvms, jvms->stkoff() + idx); |
| 0 | 364 return in(jvms->stkoff() + idx); |
| 365 } | |
| 366 Node *argument(JVMState* jvms, uint idx) const { | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6266
diff
changeset
|
367 verify_input(jvms, jvms->argoff() + idx); |
| 0 | 368 return in(jvms->argoff() + idx); |
| 369 } | |
| 370 Node *monitor_box(JVMState* jvms, uint idx) const { | |
| 371 assert(verify_jvms(jvms), "jvms must match"); | |
| 372 return in(jvms->monitor_box_offset(idx)); | |
| 373 } | |
| 374 Node *monitor_obj(JVMState* jvms, uint idx) const { | |
| 375 assert(verify_jvms(jvms), "jvms must match"); | |
| 376 return in(jvms->monitor_obj_offset(idx)); | |
| 377 } | |
| 378 | |
| 379 void set_local(JVMState* jvms, uint idx, Node *c); | |
| 380 | |
| 381 void set_stack(JVMState* jvms, uint idx, Node *c) { | |
| 382 assert(verify_jvms(jvms), "jvms must match"); | |
| 383 set_req(jvms->stkoff() + idx, c); | |
| 384 } | |
| 385 void set_argument(JVMState* jvms, uint idx, Node *c) { | |
| 386 assert(verify_jvms(jvms), "jvms must match"); | |
| 387 set_req(jvms->argoff() + idx, c); | |
| 388 } | |
| 389 void ensure_stack(JVMState* jvms, uint stk_size) { | |
| 390 assert(verify_jvms(jvms), "jvms must match"); | |
| 391 int grow_by = (int)stk_size - (int)jvms->stk_size(); | |
| 392 if (grow_by > 0) grow_stack(jvms, grow_by); | |
| 393 } | |
| 394 void grow_stack(JVMState* jvms, uint grow_by); | |
| 395 // Handle monitor stack | |
| 396 void push_monitor( const FastLockNode *lock ); | |
| 397 void pop_monitor (); | |
| 398 Node *peek_monitor_box() const; | |
| 399 Node *peek_monitor_obj() const; | |
| 400 | |
| 401 // Access functions for the JVM | |
| 402 Node *control () const { return in(TypeFunc::Control ); } | |
| 403 Node *i_o () const { return in(TypeFunc::I_O ); } | |
| 404 Node *memory () const { return in(TypeFunc::Memory ); } | |
| 405 Node *returnadr() const { return in(TypeFunc::ReturnAdr); } | |
| 406 Node *frameptr () const { return in(TypeFunc::FramePtr ); } | |
| 407 | |
| 408 void set_control ( Node *c ) { set_req(TypeFunc::Control,c); } | |
| 409 void set_i_o ( Node *c ) { set_req(TypeFunc::I_O ,c); } | |
| 410 void set_memory ( Node *c ) { set_req(TypeFunc::Memory ,c); } | |
| 411 | |
| 412 MergeMemNode* merged_memory() const { | |
| 413 return in(TypeFunc::Memory)->as_MergeMem(); | |
| 414 } | |
| 415 | |
| 416 // The parser marks useless maps as dead when it's done with them: | |
| 417 bool is_killed() { return in(TypeFunc::Control) == NULL; } | |
| 418 | |
| 419 // Exception states bubbling out of subgraphs such as inlined calls | |
| 420 // are recorded here. (There might be more than one, hence the "next".) | |
| 421 // This feature is used only for safepoints which serve as "maps" | |
| 422 // for JVM states during parsing, intrinsic expansion, etc. | |
| 423 SafePointNode* next_exception() const; | |
| 424 void set_next_exception(SafePointNode* n); | |
| 425 bool has_exceptions() const { return next_exception() != NULL; } | |
| 426 | |
| 427 // Standard Node stuff | |
| 428 virtual int Opcode() const; | |
| 429 virtual bool pinned() const { return true; } | |
| 430 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 431 virtual const Type *bottom_type() const { return Type::CONTROL; } | |
| 432 virtual const TypePtr *adr_type() const { return _adr_type; } | |
| 433 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 434 virtual Node *Identity( PhaseTransform *phase ); | |
| 435 virtual uint ideal_reg() const { return 0; } | |
| 436 virtual const RegMask &in_RegMask(uint) const; | |
| 437 virtual const RegMask &out_RegMask() const; | |
| 438 virtual uint match_edge(uint idx) const; | |
| 439 | |
| 440 static bool needs_polling_address_input(); | |
| 441 | |
| 442 #ifndef PRODUCT | |
| 10278 | 443 virtual void dump_spec(outputStream *st) const; |
| 0 | 444 #endif |
| 445 }; | |
| 446 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
447 //------------------------------SafePointScalarObjectNode---------------------- |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
448 // A SafePointScalarObjectNode represents the state of a scalarized object |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
449 // at a safepoint. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
450 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
451 class SafePointScalarObjectNode: public TypeNode { |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
452 uint _first_index; // First input edge index of a SafePoint node where |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
453 // states of the scalarized object fields are collected. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
454 uint _n_fields; // Number of non-static fields of the scalarized object. |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
65
diff
changeset
|
455 DEBUG_ONLY(AllocateNode* _alloc;) |
| 4115 | 456 |
| 457 virtual uint hash() const ; // { return NO_HASH; } | |
| 458 virtual uint cmp( const Node &n ) const; | |
| 459 | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
460 public: |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
461 SafePointScalarObjectNode(const TypeOopPtr* tp, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
462 #ifdef ASSERT |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
463 AllocateNode* alloc, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
464 #endif |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
465 uint first_index, uint n_fields); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
466 virtual int Opcode() const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
467 virtual uint ideal_reg() const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
468 virtual const RegMask &in_RegMask(uint) const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
469 virtual const RegMask &out_RegMask() const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
470 virtual uint match_edge(uint idx) const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
471 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
472 uint first_index() const { return _first_index; } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
473 uint n_fields() const { return _n_fields; } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
474 |
| 4115 | 475 #ifdef ASSERT |
| 476 AllocateNode* alloc() const { return _alloc; } | |
| 477 #endif | |
|
601
523ded093c31
6809798: SafePointScalarObject node placed into incorrect block during GCM
kvn
parents:
460
diff
changeset
|
478 |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
479 virtual uint size_of() const { return sizeof(*this); } |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
480 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
481 // Assumes that "this" is an argument to a safepoint node "s", and that |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
482 // "new_call" is being created to correspond to "s". But the difference |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
483 // between the start index of the jvmstates of "new_call" and "s" is |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
484 // "jvms_adj". Produce and return a SafePointScalarObjectNode that |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
485 // corresponds appropriately to "this" in "new_call". Assumes that |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
486 // "sosn_map" is a map, specific to the translation of "s" to "new_call", |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
487 // mapping old SafePointScalarObjectNodes to new, to avoid multiple copies. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
488 SafePointScalarObjectNode* clone(int jvms_adj, Dict* sosn_map) const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
489 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
490 #ifndef PRODUCT |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
491 virtual void dump_spec(outputStream *st) const; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
492 #endif |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
493 }; |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
39
diff
changeset
|
494 |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
495 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
496 // Simple container for the outgoing projections of a call. Useful |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
497 // for serious surgery on calls. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
498 class CallProjections : public StackObj { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
499 public: |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
500 Node* fallthrough_proj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
501 Node* fallthrough_catchproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
502 Node* fallthrough_memproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
503 Node* fallthrough_ioproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
504 Node* catchall_catchproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
505 Node* catchall_memproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
506 Node* catchall_ioproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
507 Node* resproj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
508 Node* exobj; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
509 }; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
510 |
| 7473 | 511 class CallGenerator; |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
512 |
| 0 | 513 //------------------------------CallNode--------------------------------------- |
| 514 // Call nodes now subsume the function of debug nodes at callsites, so they | |
| 515 // contain the functionality of a full scope chain of debug nodes. | |
| 516 class CallNode : public SafePointNode { | |
| 3939 | 517 friend class VMStructs; |
| 0 | 518 public: |
| 519 const TypeFunc *_tf; // Function type | |
| 520 address _entry_point; // Address of method being called | |
| 521 float _cnt; // Estimate of number of times called | |
| 7473 | 522 CallGenerator* _generator; // corresponding CallGenerator for some late inline calls |
| 0 | 523 |
| 524 CallNode(const TypeFunc* tf, address addr, const TypePtr* adr_type) | |
| 525 : SafePointNode(tf->domain()->cnt(), NULL, adr_type), | |
| 526 _tf(tf), | |
| 527 _entry_point(addr), | |
| 7473 | 528 _cnt(COUNT_UNKNOWN), |
| 529 _generator(NULL) | |
| 0 | 530 { |
| 531 init_class_id(Class_Call); | |
| 532 } | |
| 533 | |
| 7473 | 534 const TypeFunc* tf() const { return _tf; } |
| 535 const address entry_point() const { return _entry_point; } | |
| 536 const float cnt() const { return _cnt; } | |
| 537 CallGenerator* generator() const { return _generator; } | |
| 0 | 538 |
| 7473 | 539 void set_tf(const TypeFunc* tf) { _tf = tf; } |
| 540 void set_entry_point(address p) { _entry_point = p; } | |
| 541 void set_cnt(float c) { _cnt = c; } | |
| 542 void set_generator(CallGenerator* cg) { _generator = cg; } | |
| 0 | 543 |
| 544 virtual const Type *bottom_type() const; | |
| 545 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 7473 | 546 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
| 0 | 547 virtual Node *Identity( PhaseTransform *phase ) { return this; } |
| 548 virtual uint cmp( const Node &n ) const; | |
| 549 virtual uint size_of() const = 0; | |
| 550 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const; | |
| 551 virtual Node *match( const ProjNode *proj, const Matcher *m ); | |
| 552 virtual uint ideal_reg() const { return NotAMachineReg; } | |
| 553 // Are we guaranteed that this node is a safepoint? Not true for leaf calls and | |
| 554 // for some macro nodes whose expansion does not have a safepoint on the fast path. | |
| 555 virtual bool guaranteed_safepoint() { return true; } | |
| 556 // For macro nodes, the JVMState gets modified during expansion, so when cloning | |
| 557 // the node the JVMState must be cloned. | |
| 10278 | 558 virtual void clone_jvms(Compile* C) { } // default is not to clone |
| 0 | 559 |
| 65 | 560 // Returns true if the call may modify n |
| 10278 | 561 virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase); |
| 65 | 562 // Does this node have a use of n other than in debug information? |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
113
diff
changeset
|
563 bool has_non_debug_use(Node *n); |
| 65 | 564 // Returns the unique CheckCastPP of a call |
| 565 // or result projection is there are several CheckCastPP | |
| 566 // or returns NULL if there is no one. | |
| 567 Node *result_cast(); | |
|
5948
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
568 // Does this node returns pointer? |
|
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
569 bool returns_pointer() const { |
|
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
570 const TypeTuple *r = tf()->range(); |
|
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
571 return (r->cnt() > TypeFunc::Parms && |
|
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
572 r->field_at(TypeFunc::Parms)->isa_ptr()); |
|
ee138854b3a6
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
4777
diff
changeset
|
573 } |
| 65 | 574 |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
575 // Collect all the interesting edges from a call for use in |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
576 // replacing the call by something else. Used by macro expansion |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
577 // and the late inlining support. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
578 void extract_projections(CallProjections* projs, bool separate_io_proj); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
579 |
| 0 | 580 virtual uint match_edge(uint idx) const; |
| 581 | |
| 582 #ifndef PRODUCT | |
|
7636
a7114d3d712e
8005055: pass outputStream to more opto debug routines
kvn
parents:
7473
diff
changeset
|
583 virtual void dump_req(outputStream *st = tty) const; |
| 0 | 584 virtual void dump_spec(outputStream *st) const; |
| 585 #endif | |
| 586 }; | |
| 587 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
903
diff
changeset
|
588 |
| 0 | 589 //------------------------------CallJavaNode----------------------------------- |
| 590 // Make a static or dynamic subroutine call node using Java calling | |
| 591 // convention. (The "Java" calling convention is the compiler's calling | |
| 592 // convention, as opposed to the interpreter's or that of native C.) | |
| 593 class CallJavaNode : public CallNode { | |
| 3939 | 594 friend class VMStructs; |
| 0 | 595 protected: |
| 596 virtual uint cmp( const Node &n ) const; | |
| 597 virtual uint size_of() const; // Size is bigger | |
| 598 | |
| 599 bool _optimized_virtual; | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
600 bool _method_handle_invoke; |
| 0 | 601 ciMethod* _method; // Method being direct called |
| 602 public: | |
| 603 const int _bci; // Byte Code Index of call byte code | |
| 604 CallJavaNode(const TypeFunc* tf , address addr, ciMethod* method, int bci) | |
| 605 : CallNode(tf, addr, TypePtr::BOTTOM), | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
606 _method(method), _bci(bci), |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
607 _optimized_virtual(false), |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
608 _method_handle_invoke(false) |
| 0 | 609 { |
| 610 init_class_id(Class_CallJava); | |
| 611 } | |
| 612 | |
| 613 virtual int Opcode() const; | |
| 614 ciMethod* method() const { return _method; } | |
| 615 void set_method(ciMethod *m) { _method = m; } | |
| 616 void set_optimized_virtual(bool f) { _optimized_virtual = f; } | |
| 617 bool is_optimized_virtual() const { return _optimized_virtual; } | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
618 void set_method_handle_invoke(bool f) { _method_handle_invoke = f; } |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
619 bool is_method_handle_invoke() const { return _method_handle_invoke; } |
| 0 | 620 |
| 621 #ifndef PRODUCT | |
| 622 virtual void dump_spec(outputStream *st) const; | |
| 623 #endif | |
| 624 }; | |
| 625 | |
| 626 //------------------------------CallStaticJavaNode----------------------------- | |
| 627 // Make a direct subroutine call using Java calling convention (for static | |
| 628 // calls and optimized virtual calls, plus calls to wrappers for run-time | |
| 629 // routines); generates static stub. | |
| 630 class CallStaticJavaNode : public CallJavaNode { | |
| 631 virtual uint cmp( const Node &n ) const; | |
| 632 virtual uint size_of() const; // Size is bigger | |
| 633 public: | |
| 10278 | 634 CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method, int bci) |
| 0 | 635 : CallJavaNode(tf, addr, method, bci), _name(NULL) { |
| 636 init_class_id(Class_CallStaticJava); | |
| 10278 | 637 if (C->eliminate_boxing() && (method != NULL) && method->is_boxing_method()) { |
| 638 init_flags(Flag_is_macro); | |
| 639 C->add_macro_node(this); | |
| 640 } | |
| 641 _is_scalar_replaceable = false; | |
| 642 _is_non_escaping = false; | |
| 0 | 643 } |
| 644 CallStaticJavaNode(const TypeFunc* tf, address addr, const char* name, int bci, | |
| 645 const TypePtr* adr_type) | |
| 646 : CallJavaNode(tf, addr, NULL, bci), _name(name) { | |
| 647 init_class_id(Class_CallStaticJava); | |
| 648 // This node calls a runtime stub, which often has narrow memory effects. | |
| 649 _adr_type = adr_type; | |
| 10278 | 650 _is_scalar_replaceable = false; |
| 651 _is_non_escaping = false; | |
| 0 | 652 } |
| 10278 | 653 const char *_name; // Runtime wrapper name |
| 654 | |
| 655 // Result of Escape Analysis | |
| 656 bool _is_scalar_replaceable; | |
| 657 bool _is_non_escaping; | |
| 0 | 658 |
| 659 // If this is an uncommon trap, return the request code, else zero. | |
| 660 int uncommon_trap_request() const; | |
| 661 static int extract_uncommon_trap_request(const Node* call); | |
| 662 | |
| 10278 | 663 bool is_boxing_method() const { |
| 664 return is_macro() && (method() != NULL) && method()->is_boxing_method(); | |
| 665 } | |
| 666 // Later inlining modifies the JVMState, so we need to clone it | |
| 667 // when the call node is cloned (because it is macro node). | |
| 668 virtual void clone_jvms(Compile* C) { | |
| 669 if ((jvms() != NULL) && is_boxing_method()) { | |
| 670 set_jvms(jvms()->clone_deep(C)); | |
| 671 jvms()->set_map_deep(this); | |
| 672 } | |
| 673 } | |
| 674 | |
| 0 | 675 virtual int Opcode() const; |
| 676 #ifndef PRODUCT | |
| 677 virtual void dump_spec(outputStream *st) const; | |
| 678 #endif | |
| 679 }; | |
| 680 | |
| 681 //------------------------------CallDynamicJavaNode---------------------------- | |
| 682 // Make a dispatched call using Java calling convention. | |
| 683 class CallDynamicJavaNode : public CallJavaNode { | |
| 684 virtual uint cmp( const Node &n ) const; | |
| 685 virtual uint size_of() const; // Size is bigger | |
| 686 public: | |
| 687 CallDynamicJavaNode( const TypeFunc *tf , address addr, ciMethod* method, int vtable_index, int bci ) : CallJavaNode(tf,addr,method,bci), _vtable_index(vtable_index) { | |
| 688 init_class_id(Class_CallDynamicJava); | |
| 689 } | |
| 690 | |
| 691 int _vtable_index; | |
| 692 virtual int Opcode() const; | |
| 693 #ifndef PRODUCT | |
| 694 virtual void dump_spec(outputStream *st) const; | |
| 695 #endif | |
| 696 }; | |
| 697 | |
| 698 //------------------------------CallRuntimeNode-------------------------------- | |
| 699 // Make a direct subroutine call node into compiled C++ code. | |
| 700 class CallRuntimeNode : public CallNode { | |
| 701 virtual uint cmp( const Node &n ) const; | |
| 702 virtual uint size_of() const; // Size is bigger | |
| 703 public: | |
| 704 CallRuntimeNode(const TypeFunc* tf, address addr, const char* name, | |
| 705 const TypePtr* adr_type) | |
| 706 : CallNode(tf, addr, adr_type), | |
| 707 _name(name) | |
| 708 { | |
| 709 init_class_id(Class_CallRuntime); | |
| 710 } | |
| 711 | |
| 712 const char *_name; // Printable name, if _method is NULL | |
| 713 virtual int Opcode() const; | |
| 714 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const; | |
| 715 | |
| 716 #ifndef PRODUCT | |
| 717 virtual void dump_spec(outputStream *st) const; | |
| 718 #endif | |
| 719 }; | |
| 720 | |
| 721 //------------------------------CallLeafNode----------------------------------- | |
| 722 // Make a direct subroutine call node into compiled C++ code, without | |
| 723 // safepoints | |
| 724 class CallLeafNode : public CallRuntimeNode { | |
| 725 public: | |
| 726 CallLeafNode(const TypeFunc* tf, address addr, const char* name, | |
| 727 const TypePtr* adr_type) | |
| 728 : CallRuntimeNode(tf, addr, name, adr_type) | |
| 729 { | |
| 730 init_class_id(Class_CallLeaf); | |
| 731 } | |
| 732 virtual int Opcode() const; | |
| 733 virtual bool guaranteed_safepoint() { return false; } | |
| 734 #ifndef PRODUCT | |
| 735 virtual void dump_spec(outputStream *st) const; | |
| 736 #endif | |
| 737 }; | |
| 738 | |
| 739 //------------------------------CallLeafNoFPNode------------------------------- | |
| 740 // CallLeafNode, not using floating point or using it in the same manner as | |
| 741 // the generated code | |
| 742 class CallLeafNoFPNode : public CallLeafNode { | |
| 743 public: | |
| 744 CallLeafNoFPNode(const TypeFunc* tf, address addr, const char* name, | |
| 745 const TypePtr* adr_type) | |
| 746 : CallLeafNode(tf, addr, name, adr_type) | |
| 747 { | |
| 748 } | |
| 749 virtual int Opcode() const; | |
| 750 }; | |
| 751 | |
| 752 | |
| 753 //------------------------------Allocate--------------------------------------- | |
| 754 // High-level memory allocation | |
| 755 // | |
| 756 // AllocateNode and AllocateArrayNode are subclasses of CallNode because they will | |
| 757 // get expanded into a code sequence containing a call. Unlike other CallNodes, | |
| 758 // they have 2 memory projections and 2 i_o projections (which are distinguished by | |
| 759 // the _is_io_use flag in the projection.) This is needed when expanding the node in | |
| 760 // order to differentiate the uses of the projection on the normal control path from | |
| 761 // those on the exception return path. | |
| 762 // | |
| 763 class AllocateNode : public CallNode { | |
| 764 public: | |
| 765 enum { | |
| 766 // Output: | |
| 767 RawAddress = TypeFunc::Parms, // the newly-allocated raw address | |
| 768 // Inputs: | |
| 769 AllocSize = TypeFunc::Parms, // size (in bytes) of the new object | |
| 770 KlassNode, // type (maybe dynamic) of the obj. | |
| 771 InitialTest, // slow-path test (may be constant) | |
| 772 ALength, // array length (or TOP if none) | |
| 773 ParmLimit | |
| 774 }; | |
| 775 | |
| 10278 | 776 static const TypeFunc* alloc_type(const Type* t) { |
| 0 | 777 const Type** fields = TypeTuple::fields(ParmLimit - TypeFunc::Parms); |
| 778 fields[AllocSize] = TypeInt::POS; | |
| 779 fields[KlassNode] = TypeInstPtr::NOTNULL; | |
| 780 fields[InitialTest] = TypeInt::BOOL; | |
| 10278 | 781 fields[ALength] = t; // length (can be a bad length) |
| 0 | 782 |
| 783 const TypeTuple *domain = TypeTuple::make(ParmLimit, fields); | |
| 784 | |
| 785 // create result type (range) | |
| 786 fields = TypeTuple::fields(1); | |
| 787 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop | |
| 788 | |
| 789 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields); | |
| 790 | |
| 791 return TypeFunc::make(domain, range); | |
| 792 } | |
| 793 | |
| 10278 | 794 // Result of Escape Analysis |
| 795 bool _is_scalar_replaceable; | |
| 796 bool _is_non_escaping; | |
|
39
76256d272075
6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation
kvn
parents:
33
diff
changeset
|
797 |
| 0 | 798 virtual uint size_of() const; // Size is bigger |
| 799 AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio, | |
| 800 Node *size, Node *klass_node, Node *initial_test); | |
| 801 // Expansion modifies the JVMState, so we need to clone it | |
| 10278 | 802 virtual void clone_jvms(Compile* C) { |
| 803 if (jvms() != NULL) { | |
| 804 set_jvms(jvms()->clone_deep(C)); | |
| 805 jvms()->set_map_deep(this); | |
| 806 } | |
| 0 | 807 } |
| 808 virtual int Opcode() const; | |
| 809 virtual uint ideal_reg() const { return Op_RegP; } | |
| 810 virtual bool guaranteed_safepoint() { return false; } | |
| 811 | |
| 65 | 812 // allocations do not modify their arguments |
| 10278 | 813 virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { return false;} |
| 65 | 814 |
| 0 | 815 // Pattern-match a possible usage of AllocateNode. |
| 816 // Return null if no allocation is recognized. | |
| 817 // The operand is the pointer produced by the (possible) allocation. | |
| 818 // It must be a projection of the Allocate or its subsequent CastPP. | |
| 819 // (Note: This function is defined in file graphKit.cpp, near | |
| 820 // GraphKit::new_instance/new_array, whose output it recognizes.) | |
| 821 // The 'ptr' may not have an offset unless the 'offset' argument is given. | |
| 822 static AllocateNode* Ideal_allocation(Node* ptr, PhaseTransform* phase); | |
| 823 | |
| 824 // Fancy version which uses AddPNode::Ideal_base_and_offset to strip | |
| 825 // an offset, which is reported back to the caller. | |
| 826 // (Note: AllocateNode::Ideal_allocation is defined in graphKit.cpp.) | |
| 827 static AllocateNode* Ideal_allocation(Node* ptr, PhaseTransform* phase, | |
| 828 intptr_t& offset); | |
| 829 | |
| 830 // Dig the klass operand out of a (possible) allocation site. | |
| 831 static Node* Ideal_klass(Node* ptr, PhaseTransform* phase) { | |
| 832 AllocateNode* allo = Ideal_allocation(ptr, phase); | |
| 833 return (allo == NULL) ? NULL : allo->in(KlassNode); | |
| 834 } | |
| 835 | |
| 836 // Conservatively small estimate of offset of first non-header byte. | |
| 837 int minimum_header_size() { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
838 return is_AllocateArray() ? arrayOopDesc::base_offset_in_bytes(T_BYTE) : |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
839 instanceOopDesc::base_offset_in_bytes(); |
| 0 | 840 } |
| 841 | |
| 842 // Return the corresponding initialization barrier (or null if none). | |
| 843 // Walks out edges to find it... | |
| 844 // (Note: Both InitializeNode::allocation and AllocateNode::initialization | |
| 845 // are defined in graphKit.cpp, which sets up the bidirectional relation.) | |
| 846 InitializeNode* initialization(); | |
| 847 | |
| 848 // Convenience for initialization->maybe_set_complete(phase) | |
| 849 bool maybe_set_complete(PhaseGVN* phase); | |
| 850 }; | |
| 851 | |
| 852 //------------------------------AllocateArray--------------------------------- | |
| 853 // | |
| 854 // High-level array allocation | |
| 855 // | |
| 856 class AllocateArrayNode : public AllocateNode { | |
| 857 public: | |
| 858 AllocateArrayNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio, | |
| 859 Node* size, Node* klass_node, Node* initial_test, | |
| 860 Node* count_val | |
| 861 ) | |
| 862 : AllocateNode(C, atype, ctrl, mem, abio, size, klass_node, | |
| 863 initial_test) | |
| 864 { | |
| 865 init_class_id(Class_AllocateArray); | |
| 866 set_req(AllocateNode::ALength, count_val); | |
| 867 } | |
| 868 virtual int Opcode() const; | |
|
704
ad8c635e757e
6823453: DeoptimizeALot causes fastdebug server jvm to fail with assert(false,"unscheduable graph")
kvn
parents:
601
diff
changeset
|
869 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
| 0 | 870 |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
871 // Dig the length operand out of a array allocation site. |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
872 Node* Ideal_length() { |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
873 return in(AllocateNode::ALength); |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
874 } |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
875 |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
876 // Dig the length operand out of a array allocation site and narrow the |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
877 // type with a CastII, if necesssary |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
878 Node* make_ideal_length(const TypeOopPtr* ary_type, PhaseTransform *phase, bool can_create = true); |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
196
diff
changeset
|
879 |
| 0 | 880 // Pattern-match a possible usage of AllocateArrayNode. |
| 881 // Return null if no allocation is recognized. | |
| 882 static AllocateArrayNode* Ideal_array_allocation(Node* ptr, PhaseTransform* phase) { | |
| 883 AllocateNode* allo = Ideal_allocation(ptr, phase); | |
| 884 return (allo == NULL || !allo->is_AllocateArray()) | |
| 885 ? NULL : allo->as_AllocateArray(); | |
| 886 } | |
| 887 }; | |
| 888 | |
| 889 //------------------------------AbstractLockNode----------------------------------- | |
| 890 class AbstractLockNode: public CallNode { | |
| 891 private: | |
| 4777 | 892 enum { |
| 893 Regular = 0, // Normal lock | |
| 894 NonEscObj, // Lock is used for non escaping object | |
| 895 Coarsened, // Lock was coarsened | |
| 896 Nested // Nested lock | |
| 897 } _kind; | |
| 0 | 898 #ifndef PRODUCT |
| 899 NamedCounter* _counter; | |
| 900 #endif | |
| 901 | |
| 902 protected: | |
| 903 // helper functions for lock elimination | |
| 904 // | |
| 905 | |
| 906 bool find_matching_unlock(const Node* ctrl, LockNode* lock, | |
| 907 GrowableArray<AbstractLockNode*> &lock_ops); | |
| 908 bool find_lock_and_unlock_through_if(Node* node, LockNode* lock, | |
| 909 GrowableArray<AbstractLockNode*> &lock_ops); | |
| 910 bool find_unlocks_for_region(const RegionNode* region, LockNode* lock, | |
| 911 GrowableArray<AbstractLockNode*> &lock_ops); | |
| 912 LockNode *find_matching_lock(UnlockNode* unlock); | |
| 913 | |
| 4777 | 914 // Update the counter to indicate that this lock was eliminated. |
| 915 void set_eliminated_lock_counter() PRODUCT_RETURN; | |
| 0 | 916 |
| 917 public: | |
| 918 AbstractLockNode(const TypeFunc *tf) | |
| 919 : CallNode(tf, NULL, TypeRawPtr::BOTTOM), | |
| 4777 | 920 _kind(Regular) |
| 0 | 921 { |
| 922 #ifndef PRODUCT | |
| 923 _counter = NULL; | |
| 924 #endif | |
| 925 } | |
| 926 virtual int Opcode() const = 0; | |
| 927 Node * obj_node() const {return in(TypeFunc::Parms + 0); } | |
| 928 Node * box_node() const {return in(TypeFunc::Parms + 1); } | |
| 929 Node * fastlock_node() const {return in(TypeFunc::Parms + 2); } | |
| 4777 | 930 void set_box_node(Node* box) { set_req(TypeFunc::Parms + 1, box); } |
| 931 | |
| 0 | 932 const Type *sub(const Type *t1, const Type *t2) const { return TypeInt::CC;} |
| 933 | |
| 934 virtual uint size_of() const { return sizeof(*this); } | |
| 935 | |
| 4777 | 936 bool is_eliminated() const { return (_kind != Regular); } |
| 937 bool is_non_esc_obj() const { return (_kind == NonEscObj); } | |
| 938 bool is_coarsened() const { return (_kind == Coarsened); } | |
| 939 bool is_nested() const { return (_kind == Nested); } | |
| 0 | 940 |
| 4777 | 941 void set_non_esc_obj() { _kind = NonEscObj; set_eliminated_lock_counter(); } |
| 942 void set_coarsened() { _kind = Coarsened; set_eliminated_lock_counter(); } | |
| 943 void set_nested() { _kind = Nested; set_eliminated_lock_counter(); } | |
|
460
424f9bfe6b96
6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents:
420
diff
changeset
|
944 |
| 65 | 945 // locking does not modify its arguments |
| 10278 | 946 virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase){ return false;} |
| 65 | 947 |
| 0 | 948 #ifndef PRODUCT |
| 949 void create_lock_counter(JVMState* s); | |
| 950 NamedCounter* counter() const { return _counter; } | |
| 951 #endif | |
| 952 }; | |
| 953 | |
| 954 //------------------------------Lock--------------------------------------- | |
| 955 // High-level lock operation | |
| 956 // | |
| 957 // This is a subclass of CallNode because it is a macro node which gets expanded | |
| 958 // into a code sequence containing a call. This node takes 3 "parameters": | |
| 959 // 0 - object to lock | |
| 960 // 1 - a BoxLockNode | |
| 961 // 2 - a FastLockNode | |
| 962 // | |
| 963 class LockNode : public AbstractLockNode { | |
| 964 public: | |
| 965 | |
| 966 static const TypeFunc *lock_type() { | |
| 967 // create input type (domain) | |
| 968 const Type **fields = TypeTuple::fields(3); | |
| 969 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked | |
| 970 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock | |
| 971 fields[TypeFunc::Parms+2] = TypeInt::BOOL; // FastLock | |
| 972 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3,fields); | |
| 973 | |
| 974 // create result type (range) | |
| 975 fields = TypeTuple::fields(0); | |
| 976 | |
| 977 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields); | |
| 978 | |
| 979 return TypeFunc::make(domain,range); | |
| 980 } | |
| 981 | |
| 982 virtual int Opcode() const; | |
| 983 virtual uint size_of() const; // Size is bigger | |
| 984 LockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf ) { | |
| 985 init_class_id(Class_Lock); | |
| 986 init_flags(Flag_is_macro); | |
| 987 C->add_macro_node(this); | |
| 988 } | |
| 989 virtual bool guaranteed_safepoint() { return false; } | |
| 990 | |
| 991 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 992 // Expansion modifies the JVMState, so we need to clone it | |
| 10278 | 993 virtual void clone_jvms(Compile* C) { |
| 994 if (jvms() != NULL) { | |
| 995 set_jvms(jvms()->clone_deep(C)); | |
| 996 jvms()->set_map_deep(this); | |
| 997 } | |
| 0 | 998 } |
| 4777 | 999 |
| 1000 bool is_nested_lock_region(); // Is this Lock nested? | |
| 0 | 1001 }; |
| 1002 | |
| 1003 //------------------------------Unlock--------------------------------------- | |
| 1004 // High-level unlock operation | |
| 1005 class UnlockNode : public AbstractLockNode { | |
| 1006 public: | |
| 1007 virtual int Opcode() const; | |
| 1008 virtual uint size_of() const; // Size is bigger | |
| 1009 UnlockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf ) { | |
| 1010 init_class_id(Class_Unlock); | |
| 1011 init_flags(Flag_is_macro); | |
| 1012 C->add_macro_node(this); | |
| 1013 } | |
| 1014 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 1015 // unlock is never a safepoint | |
| 1016 virtual bool guaranteed_safepoint() { return false; } | |
| 1017 }; | |
| 1972 | 1018 |
| 1019 #endif // SHARE_VM_OPTO_CALLNODE_HPP |