Mercurial > hg > truffle
annotate src/share/vm/opto/graphKit.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | c18cbe5936b8 |
| children | 4b29a725c43c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
2 * Copyright (c) 2001, 2010, 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:
1213
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
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:
1213
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 class FastLockNode; | |
| 26 class FastUnlockNode; | |
| 342 | 27 class IdealKit; |
| 0 | 28 class Parse; |
| 29 class RootNode; | |
| 30 | |
| 31 //----------------------------------------------------------------------------- | |
| 32 //----------------------------GraphKit----------------------------------------- | |
| 33 // Toolkit for building the common sorts of subgraphs. | |
| 34 // Does not know about bytecode parsing or type-flow results. | |
| 35 // It is able to create graphs implementing the semantics of most | |
| 36 // or all bytecodes, so that it can expand intrinsics and calls. | |
| 37 // It may depend on JVMState structure, but it must not depend | |
| 38 // on specific bytecode streams. | |
| 39 class GraphKit : public Phase { | |
| 40 friend class PreserveJVMState; | |
| 41 | |
| 42 protected: | |
| 43 ciEnv* _env; // Compilation environment | |
| 44 PhaseGVN &_gvn; // Some optimizations while parsing | |
| 45 SafePointNode* _map; // Parser map from JVM to Nodes | |
| 46 SafePointNode* _exceptions;// Parser map(s) for exception state(s) | |
| 47 int _sp; // JVM Expression Stack Pointer | |
| 48 int _bci; // JVM Bytecode Pointer | |
| 49 ciMethod* _method; // JVM Current Method | |
| 50 | |
| 51 private: | |
| 52 SafePointNode* map_not_null() const { | |
| 53 assert(_map != NULL, "must call stopped() to test for reset compiler map"); | |
| 54 return _map; | |
| 55 } | |
| 56 | |
| 57 public: | |
| 58 GraphKit(); // empty constructor | |
| 59 GraphKit(JVMState* jvms); // the JVM state on which to operate | |
| 60 | |
| 61 #ifdef ASSERT | |
| 62 ~GraphKit() { | |
| 63 assert(!has_exceptions(), "user must call transfer_exceptions_into_jvms"); | |
| 64 } | |
| 65 #endif | |
| 66 | |
| 67 virtual Parse* is_Parse() const { return NULL; } | |
| 68 | |
| 69 ciEnv* env() const { return _env; } | |
| 70 PhaseGVN& gvn() const { return _gvn; } | |
| 71 | |
| 72 void record_for_igvn(Node* n) const { C->record_for_igvn(n); } // delegate to Compile | |
| 73 | |
| 74 // Handy well-known nodes: | |
| 75 Node* null() const { return zerocon(T_OBJECT); } | |
| 76 Node* top() const { return C->top(); } | |
| 77 RootNode* root() const { return C->root(); } | |
| 78 | |
| 79 // Create or find a constant node | |
| 80 Node* intcon(jint con) const { return _gvn.intcon(con); } | |
| 81 Node* longcon(jlong con) const { return _gvn.longcon(con); } | |
| 82 Node* makecon(const Type *t) const { return _gvn.makecon(t); } | |
| 83 Node* zerocon(BasicType bt) const { return _gvn.zerocon(bt); } | |
| 84 // (See also macro MakeConX in type.hpp, which uses intcon or longcon.) | |
| 85 | |
|
563
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
86 // Helper for byte_map_base |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
87 Node* byte_map_base_node() { |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
88 // Get base of card map |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
89 CardTableModRefBS* ct = (CardTableModRefBS*)(Universe::heap()->barrier_set()); |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
90 assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust users of this code"); |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
91 if (ct->byte_map_base != NULL) { |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
92 return makecon(TypeRawPtr::make((address)ct->byte_map_base)); |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
93 } else { |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
94 return null(); |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
95 } |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
96 } |
|
1b9fc6e3171b
6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents:
342
diff
changeset
|
97 |
| 0 | 98 jint find_int_con(Node* n, jint value_if_unknown) { |
| 99 return _gvn.find_int_con(n, value_if_unknown); | |
| 100 } | |
| 101 jlong find_long_con(Node* n, jlong value_if_unknown) { | |
| 102 return _gvn.find_long_con(n, value_if_unknown); | |
| 103 } | |
| 104 // (See also macro find_intptr_t_con in type.hpp, which uses one of these.) | |
| 105 | |
| 106 // JVM State accessors: | |
| 107 // Parser mapping from JVM indices into Nodes. | |
| 108 // Low slots are accessed by the StartNode::enum. | |
| 109 // Then come the locals at StartNode::Parms to StartNode::Parms+max_locals(); | |
| 110 // Then come JVM stack slots. | |
| 111 // Finally come the monitors, if any. | |
| 112 // See layout accessors in class JVMState. | |
| 113 | |
| 114 SafePointNode* map() const { return _map; } | |
| 115 bool has_exceptions() const { return _exceptions != NULL; } | |
| 116 JVMState* jvms() const { return map_not_null()->_jvms; } | |
| 117 int sp() const { return _sp; } | |
| 118 int bci() const { return _bci; } | |
| 119 Bytecodes::Code java_bc() const; | |
| 120 ciMethod* method() const { return _method; } | |
| 121 | |
| 122 void set_jvms(JVMState* jvms) { set_map(jvms->map()); | |
| 123 assert(jvms == this->jvms(), "sanity"); | |
| 124 _sp = jvms->sp(); | |
| 125 _bci = jvms->bci(); | |
| 126 _method = jvms->has_method() ? jvms->method() : NULL; } | |
| 127 void set_map(SafePointNode* m) { _map = m; debug_only(verify_map()); } | |
| 128 void set_sp(int i) { assert(i >= 0, "must be non-negative"); _sp = i; } | |
| 129 void clean_stack(int from_sp); // clear garbage beyond from_sp to top | |
| 130 | |
| 131 void inc_sp(int i) { set_sp(sp() + i); } | |
| 132 void set_bci(int bci) { _bci = bci; } | |
| 133 | |
| 134 // Make sure jvms has current bci & sp. | |
| 135 JVMState* sync_jvms() const; | |
| 136 #ifdef ASSERT | |
| 137 // Make sure JVMS has an updated copy of bci and sp. | |
| 138 // Also sanity-check method, depth, and monitor depth. | |
| 139 bool jvms_in_sync() const; | |
| 140 | |
| 141 // Make sure the map looks OK. | |
| 142 void verify_map() const; | |
| 143 | |
| 144 // Make sure a proposed exception state looks OK. | |
| 145 static void verify_exception_state(SafePointNode* ex_map); | |
| 146 #endif | |
| 147 | |
| 148 // Clone the existing map state. (Implements PreserveJVMState.) | |
| 149 SafePointNode* clone_map(); | |
| 150 | |
| 151 // Set the map to a clone of the given one. | |
| 152 void set_map_clone(SafePointNode* m); | |
| 153 | |
| 154 // Tell if the compilation is failing. | |
| 155 bool failing() const { return C->failing(); } | |
| 156 | |
| 157 // Set _map to NULL, signalling a stop to further bytecode execution. | |
| 158 // Preserve the map intact for future use, and return it back to the caller. | |
| 159 SafePointNode* stop() { SafePointNode* m = map(); set_map(NULL); return m; } | |
| 160 | |
| 161 // Stop, but first smash the map's inputs to NULL, to mark it dead. | |
| 162 void stop_and_kill_map(); | |
| 163 | |
| 164 // Tell if _map is NULL, or control is top. | |
| 165 bool stopped(); | |
| 166 | |
| 167 // Tell if this method or any caller method has exception handlers. | |
| 168 bool has_ex_handler(); | |
| 169 | |
| 170 // Save an exception without blowing stack contents or other JVM state. | |
| 171 // (The extra pointer is stuck with add_req on the map, beyond the JVMS.) | |
| 172 static void set_saved_ex_oop(SafePointNode* ex_map, Node* ex_oop); | |
| 173 | |
| 174 // Recover a saved exception from its map. | |
| 175 static Node* saved_ex_oop(SafePointNode* ex_map); | |
| 176 | |
| 177 // Recover a saved exception from its map, and remove it from the map. | |
| 178 static Node* clear_saved_ex_oop(SafePointNode* ex_map); | |
| 179 | |
| 180 #ifdef ASSERT | |
| 181 // Recover a saved exception from its map, and remove it from the map. | |
| 182 static bool has_saved_ex_oop(SafePointNode* ex_map); | |
| 183 #endif | |
| 184 | |
| 185 // Push an exception in the canonical position for handlers (stack(0)). | |
| 186 void push_ex_oop(Node* ex_oop) { | |
| 187 ensure_stack(1); // ensure room to push the exception | |
| 188 set_stack(0, ex_oop); | |
| 189 set_sp(1); | |
| 190 clean_stack(1); | |
| 191 } | |
| 192 | |
| 193 // Detach and return an exception state. | |
| 194 SafePointNode* pop_exception_state() { | |
| 195 SafePointNode* ex_map = _exceptions; | |
| 196 if (ex_map != NULL) { | |
| 197 _exceptions = ex_map->next_exception(); | |
| 198 ex_map->set_next_exception(NULL); | |
| 199 debug_only(verify_exception_state(ex_map)); | |
| 200 } | |
| 201 return ex_map; | |
| 202 } | |
| 203 | |
| 204 // Add an exception, using the given JVM state, without commoning. | |
| 205 void push_exception_state(SafePointNode* ex_map) { | |
| 206 debug_only(verify_exception_state(ex_map)); | |
| 207 ex_map->set_next_exception(_exceptions); | |
| 208 _exceptions = ex_map; | |
| 209 } | |
| 210 | |
| 211 // Turn the current JVM state into an exception state, appending the ex_oop. | |
| 212 SafePointNode* make_exception_state(Node* ex_oop); | |
| 213 | |
| 214 // Add an exception, using the given JVM state. | |
| 215 // Combine all exceptions with a common exception type into a single state. | |
| 216 // (This is done via combine_exception_states.) | |
| 217 void add_exception_state(SafePointNode* ex_map); | |
| 218 | |
| 219 // Combine all exceptions of any sort whatever into a single master state. | |
| 220 SafePointNode* combine_and_pop_all_exception_states() { | |
| 221 if (_exceptions == NULL) return NULL; | |
| 222 SafePointNode* phi_map = pop_exception_state(); | |
| 223 SafePointNode* ex_map; | |
| 224 while ((ex_map = pop_exception_state()) != NULL) { | |
| 225 combine_exception_states(ex_map, phi_map); | |
| 226 } | |
| 227 return phi_map; | |
| 228 } | |
| 229 | |
| 230 // Combine the two exception states, building phis as necessary. | |
| 231 // The second argument is updated to include contributions from the first. | |
| 232 void combine_exception_states(SafePointNode* ex_map, SafePointNode* phi_map); | |
| 233 | |
| 234 // Reset the map to the given state. If there are any half-finished phis | |
| 235 // in it (created by combine_exception_states), transform them now. | |
| 236 // Returns the exception oop. (Caller must call push_ex_oop if required.) | |
| 237 Node* use_exception_state(SafePointNode* ex_map); | |
| 238 | |
| 239 // Collect exceptions from a given JVM state into my exception list. | |
| 240 void add_exception_states_from(JVMState* jvms); | |
| 241 | |
| 242 // Collect all raised exceptions into the current JVM state. | |
| 243 // Clear the current exception list and map, returns the combined states. | |
| 244 JVMState* transfer_exceptions_into_jvms(); | |
| 245 | |
| 246 // Helper to throw a built-in exception. | |
| 247 // Range checks take the offending index. | |
| 248 // Cast and array store checks take the offending class. | |
| 249 // Others do not take the optional argument. | |
| 250 // The JVMS must allow the bytecode to be re-executed | |
| 251 // via an uncommon trap. | |
| 252 void builtin_throw(Deoptimization::DeoptReason reason, Node* arg = NULL); | |
| 253 | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1080
diff
changeset
|
254 // Helper to check the JavaThread::_should_post_on_exceptions flag |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1080
diff
changeset
|
255 // and branch to an uncommon_trap if it is true (with the specified reason and must_throw) |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1080
diff
changeset
|
256 void uncommon_trap_if_should_post_on_exceptions(Deoptimization::DeoptReason reason, |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1080
diff
changeset
|
257 bool must_throw) ; |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1080
diff
changeset
|
258 |
| 0 | 259 // Helper Functions for adding debug information |
| 260 void kill_dead_locals(); | |
| 261 #ifdef ASSERT | |
| 262 bool dead_locals_are_killed(); | |
| 263 #endif | |
| 264 // The call may deoptimize. Supply required JVM state as debug info. | |
| 265 // If must_throw is true, the call is guaranteed not to return normally. | |
| 266 void add_safepoint_edges(SafePointNode* call, | |
| 267 bool must_throw = false); | |
| 268 | |
| 269 // How many stack inputs does the current BC consume? | |
| 270 // And, how does the stack change after the bytecode? | |
| 271 // Returns false if unknown. | |
| 272 bool compute_stack_effects(int& inputs, int& depth); | |
| 273 | |
| 274 // Add a fixed offset to a pointer | |
| 275 Node* basic_plus_adr(Node* base, Node* ptr, intptr_t offset) { | |
| 276 return basic_plus_adr(base, ptr, MakeConX(offset)); | |
| 277 } | |
| 278 Node* basic_plus_adr(Node* base, intptr_t offset) { | |
| 279 return basic_plus_adr(base, base, MakeConX(offset)); | |
| 280 } | |
| 281 // Add a variable offset to a pointer | |
| 282 Node* basic_plus_adr(Node* base, Node* offset) { | |
| 283 return basic_plus_adr(base, base, offset); | |
| 284 } | |
| 285 Node* basic_plus_adr(Node* base, Node* ptr, Node* offset); | |
| 286 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
287 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
288 // Some convenient shortcuts for common nodes |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
289 Node* IfTrue(IfNode* iff) { return _gvn.transform(new (C,1) IfTrueNode(iff)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
290 Node* IfFalse(IfNode* iff) { return _gvn.transform(new (C,1) IfFalseNode(iff)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
291 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
292 Node* AddI(Node* l, Node* r) { return _gvn.transform(new (C,3) AddINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
293 Node* SubI(Node* l, Node* r) { return _gvn.transform(new (C,3) SubINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
294 Node* MulI(Node* l, Node* r) { return _gvn.transform(new (C,3) MulINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
295 Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new (C,3) DivINode(ctl, l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
296 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
297 Node* AndI(Node* l, Node* r) { return _gvn.transform(new (C,3) AndINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
298 Node* OrI(Node* l, Node* r) { return _gvn.transform(new (C,3) OrINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
299 Node* XorI(Node* l, Node* r) { return _gvn.transform(new (C,3) XorINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
300 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
301 Node* MaxI(Node* l, Node* r) { return _gvn.transform(new (C,3) MaxINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
302 Node* MinI(Node* l, Node* r) { return _gvn.transform(new (C,3) MinINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
303 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
304 Node* LShiftI(Node* l, Node* r) { return _gvn.transform(new (C,3) LShiftINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
305 Node* RShiftI(Node* l, Node* r) { return _gvn.transform(new (C,3) RShiftINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
306 Node* URShiftI(Node* l, Node* r) { return _gvn.transform(new (C,3) URShiftINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
307 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
308 Node* CmpI(Node* l, Node* r) { return _gvn.transform(new (C,3) CmpINode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
309 Node* CmpL(Node* l, Node* r) { return _gvn.transform(new (C,3) CmpLNode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
310 Node* CmpP(Node* l, Node* r) { return _gvn.transform(new (C,3) CmpPNode(l, r)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
311 Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new (C,2) BoolNode(cmp, relop)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
312 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
313 Node* AddP(Node* b, Node* a, Node* o) { return _gvn.transform(new (C,4) AddPNode(b, a, o)); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
314 |
| 0 | 315 // Convert between int and long, and size_t. |
| 316 // (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.) | |
| 317 Node* ConvI2L(Node* offset); | |
| 318 Node* ConvL2I(Node* offset); | |
| 319 // Find out the klass of an object. | |
| 320 Node* load_object_klass(Node* object); | |
| 321 // Find out the length of an array. | |
| 322 Node* load_array_length(Node* array); | |
| 323 // Helper function to do a NULL pointer check or ZERO check based on type. | |
| 324 Node* null_check_common(Node* value, BasicType type, | |
| 325 bool assert_null, Node* *null_control); | |
| 326 // Throw an exception if a given value is null. | |
| 327 // Return the value cast to not-null. | |
| 328 // Be clever about equivalent dominating null checks. | |
| 329 Node* do_null_check(Node* value, BasicType type) { | |
| 330 return null_check_common(value, type, false, NULL); | |
| 331 } | |
| 332 // Throw an uncommon trap if a given value is __not__ null. | |
| 333 // Return the value cast to null, and be clever about dominating checks. | |
| 334 Node* do_null_assert(Node* value, BasicType type) { | |
| 335 return null_check_common(value, type, true, NULL); | |
| 336 } | |
| 337 // Null check oop. Return null-path control into (*null_control). | |
| 338 // Return a cast-not-null node which depends on the not-null control. | |
| 339 // If never_see_null, use an uncommon trap (*null_control sees a top). | |
| 340 // The cast is not valid along the null path; keep a copy of the original. | |
| 341 Node* null_check_oop(Node* value, Node* *null_control, | |
| 342 bool never_see_null = false); | |
| 343 | |
| 344 // Cast obj to not-null on this path | |
| 345 Node* cast_not_null(Node* obj, bool do_replace_in_map = true); | |
| 346 // Replace all occurrences of one node by another. | |
| 347 void replace_in_map(Node* old, Node* neww); | |
| 348 | |
| 349 void push(Node* n) { map_not_null(); _map->set_stack(_map->_jvms,_sp++,n); } | |
| 350 Node* pop() { map_not_null(); return _map->stack(_map->_jvms,--_sp); } | |
| 351 Node* peek(int off=0) { map_not_null(); return _map->stack(_map->_jvms, _sp - off - 1); } | |
| 352 | |
| 353 void push_pair(Node* ldval) { | |
| 354 push(ldval); | |
| 355 push(top()); // the halfword is merely a placeholder | |
| 356 } | |
| 357 void push_pair_local(int i) { | |
| 358 // longs are stored in locals in "push" order | |
| 359 push( local(i+0) ); // the real value | |
| 360 assert(local(i+1) == top(), ""); | |
| 361 push(top()); // halfword placeholder | |
| 362 } | |
| 363 Node* pop_pair() { | |
| 364 // the second half is pushed last & popped first; it contains exactly nothing | |
| 365 Node* halfword = pop(); | |
| 366 assert(halfword == top(), ""); | |
| 367 // the long bits are pushed first & popped last: | |
| 368 return pop(); | |
| 369 } | |
| 370 void set_pair_local(int i, Node* lval) { | |
| 371 // longs are stored in locals as a value/half pair (like doubles) | |
| 372 set_local(i+0, lval); | |
| 373 set_local(i+1, top()); | |
| 374 } | |
| 375 | |
| 376 // Push the node, which may be zero, one, or two words. | |
| 377 void push_node(BasicType n_type, Node* n) { | |
| 378 int n_size = type2size[n_type]; | |
| 379 if (n_size == 1) push( n ); // T_INT, ... | |
| 380 else if (n_size == 2) push_pair( n ); // T_DOUBLE, T_LONG | |
| 381 else { assert(n_size == 0, "must be T_VOID"); } | |
| 382 } | |
| 383 | |
| 384 Node* pop_node(BasicType n_type) { | |
| 385 int n_size = type2size[n_type]; | |
| 386 if (n_size == 1) return pop(); | |
| 387 else if (n_size == 2) return pop_pair(); | |
| 388 else return NULL; | |
| 389 } | |
| 390 | |
| 391 Node* control() const { return map_not_null()->control(); } | |
| 392 Node* i_o() const { return map_not_null()->i_o(); } | |
| 393 Node* returnadr() const { return map_not_null()->returnadr(); } | |
| 394 Node* frameptr() const { return map_not_null()->frameptr(); } | |
| 395 Node* local(uint idx) const { map_not_null(); return _map->local( _map->_jvms, idx); } | |
| 396 Node* stack(uint idx) const { map_not_null(); return _map->stack( _map->_jvms, idx); } | |
| 397 Node* argument(uint idx) const { map_not_null(); return _map->argument( _map->_jvms, idx); } | |
| 398 Node* monitor_box(uint idx) const { map_not_null(); return _map->monitor_box(_map->_jvms, idx); } | |
| 399 Node* monitor_obj(uint idx) const { map_not_null(); return _map->monitor_obj(_map->_jvms, idx); } | |
| 400 | |
| 401 void set_control (Node* c) { map_not_null()->set_control(c); } | |
| 402 void set_i_o (Node* c) { map_not_null()->set_i_o(c); } | |
| 403 void set_local(uint idx, Node* c) { map_not_null(); _map->set_local( _map->_jvms, idx, c); } | |
| 404 void set_stack(uint idx, Node* c) { map_not_null(); _map->set_stack( _map->_jvms, idx, c); } | |
| 405 void set_argument(uint idx, Node* c){ map_not_null(); _map->set_argument(_map->_jvms, idx, c); } | |
| 406 void ensure_stack(uint stk_size) { map_not_null(); _map->ensure_stack(_map->_jvms, stk_size); } | |
| 407 | |
| 408 // Access unaliased memory | |
| 409 Node* memory(uint alias_idx); | |
| 410 Node* memory(const TypePtr *tp) { return memory(C->get_alias_index(tp)); } | |
| 411 Node* memory(Node* adr) { return memory(_gvn.type(adr)->is_ptr()); } | |
| 412 | |
| 413 // Access immutable memory | |
| 414 Node* immutable_memory() { return C->immutable_memory(); } | |
| 415 | |
| 416 // Set unaliased memory | |
| 417 void set_memory(Node* c, uint alias_idx) { merged_memory()->set_memory_at(alias_idx, c); } | |
| 418 void set_memory(Node* c, const TypePtr *tp) { set_memory(c,C->get_alias_index(tp)); } | |
| 419 void set_memory(Node* c, Node* adr) { set_memory(c,_gvn.type(adr)->is_ptr()); } | |
| 420 | |
| 421 // Get the entire memory state (probably a MergeMemNode), and reset it | |
| 422 // (The resetting prevents somebody from using the dangling Node pointer.) | |
| 423 Node* reset_memory(); | |
| 424 | |
| 425 // Get the entire memory state, asserted to be a MergeMemNode. | |
| 426 MergeMemNode* merged_memory() { | |
| 427 Node* mem = map_not_null()->memory(); | |
| 428 assert(mem->is_MergeMem(), "parse memory is always pre-split"); | |
| 429 return mem->as_MergeMem(); | |
| 430 } | |
| 431 | |
| 432 // Set the entire memory state; produce a new MergeMemNode. | |
| 433 void set_all_memory(Node* newmem); | |
| 434 | |
| 435 // Create a memory projection from the call, then set_all_memory. | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
436 void set_all_memory_call(Node* call, bool separate_io_proj = false); |
| 0 | 437 |
| 438 // Create a LoadNode, reading from the parser's memory state. | |
| 439 // (Note: require_atomic_access is useful only with T_LONG.) | |
| 440 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, | |
| 441 bool require_atomic_access = false) { | |
| 442 // This version computes alias_index from bottom_type | |
| 443 return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(), | |
| 444 require_atomic_access); | |
| 445 } | |
| 446 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type, bool require_atomic_access = false) { | |
| 447 // This version computes alias_index from an address type | |
| 448 assert(adr_type != NULL, "use other make_load factory"); | |
| 449 return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type), | |
| 450 require_atomic_access); | |
| 451 } | |
| 452 // This is the base version which is given an alias index. | |
| 453 Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx, bool require_atomic_access = false); | |
| 454 | |
| 455 // Create & transform a StoreNode and store the effect into the | |
| 456 // parser's memory state. | |
| 457 Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt, | |
| 458 const TypePtr* adr_type, | |
| 459 bool require_atomic_access = false) { | |
| 460 // This version computes alias_index from an address type | |
| 461 assert(adr_type != NULL, "use other store_to_memory factory"); | |
| 462 return store_to_memory(ctl, adr, val, bt, | |
| 463 C->get_alias_index(adr_type), | |
| 464 require_atomic_access); | |
| 465 } | |
| 466 // This is the base version which is given alias index | |
| 467 // Return the new StoreXNode | |
| 468 Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt, | |
| 469 int adr_idx, | |
| 470 bool require_atomic_access = false); | |
| 471 | |
| 472 | |
| 473 // All in one pre-barrier, store, post_barrier | |
| 474 // Insert a write-barrier'd store. This is to let generational GC | |
| 475 // work; we have to flag all oop-stores before the next GC point. | |
| 476 // | |
| 477 // It comes in 3 flavors of store to an object, array, or unknown. | |
| 478 // We use precise card marks for arrays to avoid scanning the entire | |
| 479 // array. We use imprecise for object. We use precise for unknown | |
| 480 // since we don't know if we have an array or and object or even | |
| 481 // where the object starts. | |
| 482 // | |
| 483 // If val==NULL, it is taken to be a completely unknown value. QQQ | |
| 484 | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
485 Node* store_oop(Node* ctl, |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
486 Node* obj, // containing obj |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
487 Node* adr, // actual adress to store val at |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
488 const TypePtr* adr_type, |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
489 Node* val, |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
490 const TypeOopPtr* val_type, |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
491 BasicType bt, |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
492 bool use_precise); |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
493 |
| 0 | 494 Node* store_oop_to_object(Node* ctl, |
| 495 Node* obj, // containing obj | |
| 496 Node* adr, // actual adress to store val at | |
| 497 const TypePtr* adr_type, | |
| 498 Node* val, | |
| 825 | 499 const TypeOopPtr* val_type, |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
500 BasicType bt) { |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
501 return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, false); |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
502 } |
| 0 | 503 |
| 504 Node* store_oop_to_array(Node* ctl, | |
| 505 Node* obj, // containing obj | |
| 506 Node* adr, // actual adress to store val at | |
| 507 const TypePtr* adr_type, | |
| 508 Node* val, | |
| 825 | 509 const TypeOopPtr* val_type, |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
510 BasicType bt) { |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
511 return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true); |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
512 } |
| 0 | 513 |
| 514 // Could be an array or object we don't know at compile time (unsafe ref.) | |
| 515 Node* store_oop_to_unknown(Node* ctl, | |
| 516 Node* obj, // containing obj | |
| 517 Node* adr, // actual adress to store val at | |
| 518 const TypePtr* adr_type, | |
| 519 Node* val, | |
| 520 BasicType bt); | |
| 521 | |
| 522 // For the few case where the barriers need special help | |
| 523 void pre_barrier(Node* ctl, Node* obj, Node* adr, uint adr_idx, | |
| 825 | 524 Node* val, const TypeOopPtr* val_type, BasicType bt); |
| 0 | 525 |
| 526 void post_barrier(Node* ctl, Node* store, Node* obj, Node* adr, uint adr_idx, | |
| 527 Node* val, BasicType bt, bool use_precise); | |
| 528 | |
| 529 // Return addressing for an array element. | |
| 530 Node* array_element_address(Node* ary, Node* idx, BasicType elembt, | |
| 531 // Optional constraint on the array size: | |
| 532 const TypeInt* sizetype = NULL); | |
| 533 | |
| 534 // Return a load of array element at idx. | |
| 535 Node* load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype); | |
| 536 | |
| 537 //---------------- Dtrace support -------------------- | |
| 538 void make_dtrace_method_entry_exit(ciMethod* method, bool is_entry); | |
| 539 void make_dtrace_method_entry(ciMethod* method) { | |
| 540 make_dtrace_method_entry_exit(method, true); | |
| 541 } | |
| 542 void make_dtrace_method_exit(ciMethod* method) { | |
| 543 make_dtrace_method_entry_exit(method, false); | |
| 544 } | |
| 545 | |
| 546 //--------------- stub generation ------------------- | |
| 547 public: | |
| 548 void gen_stub(address C_function, | |
| 549 const char *name, | |
| 550 int is_fancy_jump, | |
| 551 bool pass_tls, | |
| 552 bool return_pc); | |
| 553 | |
| 554 //---------- help for generating calls -------------- | |
| 555 | |
| 556 // Do a null check on the receiver, which is in argument(0). | |
| 557 Node* null_check_receiver(ciMethod* callee) { | |
| 558 assert(!callee->is_static(), "must be a virtual method"); | |
| 559 int nargs = 1 + callee->signature()->size(); | |
| 560 // Null check on self without removing any arguments. The argument | |
| 561 // null check technically happens in the wrong place, which can lead to | |
| 562 // invalid stack traces when the primitive is inlined into a method | |
| 563 // which handles NullPointerExceptions. | |
| 564 Node* receiver = argument(0); | |
| 565 _sp += nargs; | |
| 566 receiver = do_null_check(receiver, T_OBJECT); | |
| 567 _sp -= nargs; | |
| 568 return receiver; | |
| 569 } | |
| 570 | |
| 571 // Fill in argument edges for the call from argument(0), argument(1), ... | |
| 572 // (The next step is to call set_edges_for_java_call.) | |
| 573 void set_arguments_for_java_call(CallJavaNode* call); | |
| 574 | |
| 575 // Fill in non-argument edges for the call. | |
| 576 // Transform the call, and update the basics: control, i_o, memory. | |
| 577 // (The next step is usually to call set_results_for_java_call.) | |
| 578 void set_edges_for_java_call(CallJavaNode* call, | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
579 bool must_throw = false, bool separate_io_proj = false); |
| 0 | 580 |
| 581 // Finish up a java call that was started by set_edges_for_java_call. | |
| 582 // Call add_exception on any throw arising from the call. | |
| 583 // Return the call result (transformed). | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
584 Node* set_results_for_java_call(CallJavaNode* call, bool separate_io_proj = false); |
| 0 | 585 |
| 586 // Similar to set_edges_for_java_call, but simplified for runtime calls. | |
| 587 void set_predefined_output_for_runtime_call(Node* call) { | |
| 588 set_predefined_output_for_runtime_call(call, NULL, NULL); | |
| 589 } | |
| 590 void set_predefined_output_for_runtime_call(Node* call, | |
| 591 Node* keep_mem, | |
| 592 const TypePtr* hook_mem); | |
| 593 Node* set_predefined_input_for_runtime_call(SafePointNode* call); | |
| 594 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
595 // Replace the call with the current state of the kit. Requires |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
596 // that the call was generated with separate io_projs so that |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
597 // exceptional control flow can be handled properly. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
598 void replace_call(CallNode* call, Node* result); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
985
diff
changeset
|
599 |
| 0 | 600 // helper functions for statistics |
| 601 void increment_counter(address counter_addr); // increment a debug counter | |
| 602 void increment_counter(Node* counter_addr); // increment a debug counter | |
| 603 | |
| 604 // Bail out to the interpreter right now | |
| 605 // The optional klass is the one causing the trap. | |
| 606 // The optional reason is debug information written to the compile log. | |
| 607 // Optional must_throw is the same as with add_safepoint_edges. | |
| 608 void uncommon_trap(int trap_request, | |
| 609 ciKlass* klass = NULL, const char* reason_string = NULL, | |
| 610 bool must_throw = false, bool keep_exact_action = false); | |
| 611 | |
| 612 // Shorthand, to avoid saying "Deoptimization::" so many times. | |
| 613 void uncommon_trap(Deoptimization::DeoptReason reason, | |
| 614 Deoptimization::DeoptAction action, | |
| 615 ciKlass* klass = NULL, const char* reason_string = NULL, | |
| 616 bool must_throw = false, bool keep_exact_action = false) { | |
| 617 uncommon_trap(Deoptimization::make_trap_request(reason, action), | |
| 618 klass, reason_string, must_throw, keep_exact_action); | |
| 619 } | |
| 620 | |
| 621 // Report if there were too many traps at the current method and bci. | |
| 622 // Report if a trap was recorded, and/or PerMethodTrapLimit was exceeded. | |
| 623 // If there is no MDO at all, report no trap unless told to assume it. | |
| 624 bool too_many_traps(Deoptimization::DeoptReason reason) { | |
| 625 return C->too_many_traps(method(), bci(), reason); | |
| 626 } | |
| 627 | |
| 628 // Report if there were too many recompiles at the current method and bci. | |
| 629 bool too_many_recompiles(Deoptimization::DeoptReason reason) { | |
| 630 return C->too_many_recompiles(method(), bci(), reason); | |
| 631 } | |
| 632 | |
| 633 // Returns the object (if any) which was created the moment before. | |
| 634 Node* just_allocated_object(Node* current_control); | |
| 635 | |
| 636 static bool use_ReduceInitialCardMarks() { | |
| 637 return (ReduceInitialCardMarks | |
| 638 && Universe::heap()->can_elide_tlab_store_barriers()); | |
| 639 } | |
| 640 | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
641 void sync_kit(IdealKit& ideal); |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
642 |
|
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
643 // vanilla/CMS post barrier |
|
985
685e959d09ea
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
900
diff
changeset
|
644 void write_barrier_post(Node *store, Node* obj, |
|
685e959d09ea
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
900
diff
changeset
|
645 Node* adr, uint adr_idx, Node* val, bool use_precise); |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
825
diff
changeset
|
646 |
| 342 | 647 // G1 pre/post barriers |
| 648 void g1_write_barrier_pre(Node* obj, | |
| 649 Node* adr, | |
| 650 uint alias_idx, | |
| 651 Node* val, | |
| 825 | 652 const TypeOopPtr* val_type, |
| 342 | 653 BasicType bt); |
| 654 | |
| 655 void g1_write_barrier_post(Node* store, | |
| 656 Node* obj, | |
| 657 Node* adr, | |
| 658 uint alias_idx, | |
| 659 Node* val, | |
| 660 BasicType bt, | |
| 661 bool use_precise); | |
| 662 // Helper function for g1 | |
| 663 private: | |
|
985
685e959d09ea
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
900
diff
changeset
|
664 void g1_mark_card(IdealKit& ideal, Node* card_adr, Node* store, uint oop_alias_idx, |
|
685e959d09ea
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
900
diff
changeset
|
665 Node* index, Node* index_adr, |
| 342 | 666 Node* buffer, const TypeFunc* tf); |
| 667 | |
| 668 public: | |
| 0 | 669 // Helper function to round double arguments before a call |
| 670 void round_double_arguments(ciMethod* dest_method); | |
| 671 void round_double_result(ciMethod* dest_method); | |
| 672 | |
| 673 // rounding for strict float precision conformance | |
| 674 Node* precision_rounding(Node* n); | |
| 675 | |
| 676 // rounding for strict double precision conformance | |
| 677 Node* dprecision_rounding(Node* n); | |
| 678 | |
| 679 // rounding for non-strict double stores | |
| 680 Node* dstore_rounding(Node* n); | |
| 681 | |
| 682 // Helper functions for fast/slow path codes | |
| 683 Node* opt_iff(Node* region, Node* iff); | |
| 684 Node* make_runtime_call(int flags, | |
| 685 const TypeFunc* call_type, address call_addr, | |
| 686 const char* call_name, | |
| 687 const TypePtr* adr_type, // NULL if no memory effects | |
| 688 Node* parm0 = NULL, Node* parm1 = NULL, | |
| 689 Node* parm2 = NULL, Node* parm3 = NULL, | |
| 690 Node* parm4 = NULL, Node* parm5 = NULL, | |
| 691 Node* parm6 = NULL, Node* parm7 = NULL); | |
| 692 enum { // flag values for make_runtime_call | |
| 693 RC_NO_FP = 1, // CallLeafNoFPNode | |
| 694 RC_NO_IO = 2, // do not hook IO edges | |
| 695 RC_NO_LEAF = 4, // CallStaticJavaNode | |
| 696 RC_MUST_THROW = 8, // flag passed to add_safepoint_edges | |
| 697 RC_NARROW_MEM = 16, // input memory is same as output | |
| 698 RC_UNCOMMON = 32, // freq. expected to be like uncommon trap | |
| 699 RC_LEAF = 0 // null value: no flags set | |
| 700 }; | |
| 701 | |
| 702 // merge in all memory slices from new_mem, along the given path | |
| 703 void merge_memory(Node* new_mem, Node* region, int new_path); | |
| 704 void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj); | |
| 705 | |
| 706 // Helper functions to build synchronizations | |
| 707 int next_monitor(); | |
| 708 Node* insert_mem_bar(int opcode, Node* precedent = NULL); | |
| 709 Node* insert_mem_bar_volatile(int opcode, int alias_idx, Node* precedent = NULL); | |
| 710 // Optional 'precedent' is appended as an extra edge, to force ordering. | |
| 711 FastLockNode* shared_lock(Node* obj); | |
| 712 void shared_unlock(Node* box, Node* obj); | |
| 713 | |
| 714 // helper functions for the fast path/slow path idioms | |
| 715 Node* fast_and_slow(Node* in, const Type *result_type, Node* null_result, IfNode* fast_test, Node* fast_result, address slow_call, const TypeFunc *slow_call_type, Node* slow_arg, klassOop ex_klass, Node* slow_result); | |
| 716 | |
| 717 // Generate an instance-of idiom. Used by both the instance-of bytecode | |
| 718 // and the reflective instance-of call. | |
| 719 Node* gen_instanceof( Node *subobj, Node* superkls ); | |
| 720 | |
| 721 // Generate a check-cast idiom. Used by both the check-cast bytecode | |
| 722 // and the array-store bytecode | |
| 723 Node* gen_checkcast( Node *subobj, Node* superkls, | |
| 724 Node* *failure_control = NULL ); | |
| 725 | |
| 726 // Generate a subtyping check. Takes as input the subtype and supertype. | |
| 727 // Returns 2 values: sets the default control() to the true path and | |
| 728 // returns the false path. Only reads from constant memory taken from the | |
| 729 // default memory; does not write anything. It also doesn't take in an | |
| 730 // Object; if you wish to check an Object you need to load the Object's | |
| 731 // class prior to coming here. | |
| 732 Node* gen_subtype_check(Node* subklass, Node* superklass); | |
| 733 | |
| 734 // Static parse-time type checking logic for gen_subtype_check: | |
| 735 enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test }; | |
| 736 int static_subtype_check(ciKlass* superk, ciKlass* subk); | |
| 737 | |
| 738 // Exact type check used for predicted calls and casts. | |
| 739 // Rewrites (*casted_receiver) to be casted to the stronger type. | |
| 740 // (Caller is responsible for doing replace_in_map.) | |
| 741 Node* type_check_receiver(Node* receiver, ciKlass* klass, float prob, | |
| 742 Node* *casted_receiver); | |
| 743 | |
| 744 // implementation of object creation | |
| 745 Node* set_output_for_allocation(AllocateNode* alloc, | |
| 746 const TypeOopPtr* oop_type, | |
| 747 bool raw_mem_only); | |
| 748 Node* get_layout_helper(Node* klass_node, jint& constant_value); | |
| 749 Node* new_instance(Node* klass_node, | |
| 750 Node* slow_test = NULL, | |
| 751 bool raw_mem_only = false, | |
| 752 Node* *return_size_val = NULL); | |
|
730
9c6be3edf0dc
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
579
diff
changeset
|
753 Node* new_array(Node* klass_node, Node* count_val, int nargs, |
| 0 | 754 bool raw_mem_only = false, Node* *return_size_val = NULL); |
| 755 | |
| 756 // Handy for making control flow | |
| 757 IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) { | |
| 758 IfNode* iff = new (C, 2) IfNode(ctrl, tst, prob, cnt);// New IfNode's | |
| 759 _gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time | |
| 760 // Place 'if' on worklist if it will be in graph | |
| 761 if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later | |
| 762 return iff; | |
| 763 } | |
| 764 | |
| 765 IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) { | |
| 766 IfNode* iff = new (C, 2) IfNode(ctrl, tst, prob, cnt);// New IfNode's | |
| 767 _gvn.transform(iff); // Value may be known at parse-time | |
| 768 // Place 'if' on worklist if it will be in graph | |
| 769 if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later | |
| 770 return iff; | |
| 771 } | |
| 772 }; | |
| 773 | |
| 774 // Helper class to support building of control flow branches. Upon | |
| 775 // creation the map and sp at bci are cloned and restored upon de- | |
| 776 // struction. Typical use: | |
| 777 // | |
| 778 // { PreserveJVMState pjvms(this); | |
| 779 // // code of new branch | |
| 780 // } | |
| 781 // // here the JVM state at bci is established | |
| 782 | |
| 783 class PreserveJVMState: public StackObj { | |
| 784 protected: | |
| 785 GraphKit* _kit; | |
| 786 #ifdef ASSERT | |
| 787 int _block; // PO of current block, if a Parse | |
| 788 int _bci; | |
| 789 #endif | |
| 790 SafePointNode* _map; | |
| 791 uint _sp; | |
| 792 | |
| 793 public: | |
| 794 PreserveJVMState(GraphKit* kit, bool clone_map = true); | |
| 795 ~PreserveJVMState(); | |
| 796 }; | |
| 797 | |
| 798 // Helper class to build cutouts of the form if (p) ; else {x...}. | |
| 799 // The code {x...} must not fall through. | |
| 800 // The kit's main flow of control is set to the "then" continuation of if(p). | |
| 801 class BuildCutout: public PreserveJVMState { | |
| 802 public: | |
| 803 BuildCutout(GraphKit* kit, Node* p, float prob, float cnt = COUNT_UNKNOWN); | |
| 804 ~BuildCutout(); | |
| 805 }; | |
|
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
806 |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
807 // Helper class to preserve the original _reexecute bit and _sp and restore |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
808 // them back |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
809 class PreserveReexecuteState: public StackObj { |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
810 protected: |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
811 GraphKit* _kit; |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
812 uint _sp; |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
813 JVMState::ReexecuteState _reexecute; |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
814 |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
815 public: |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
816 PreserveReexecuteState(GraphKit* kit); |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
817 ~PreserveReexecuteState(); |
|
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
851
diff
changeset
|
818 }; |