truffle: src/share/vm/opto/graphKit.cpp comparison

comparison src/share/vm/opto/graphKit.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 e7b3d177adda
children

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 _gvn.set_type(phi, dsttype);
 }
 }
 }
 }
+phi_map->merge_replaced_nodes_with(ex_map);
 }
 //--------------------------use_exception_state--------------------------------
 Node* GraphKit::use_exception_state(SafePointNode* phi_map) {
 if (failing()) { stop(); return top(); }
 debug_only(kit->verify_map());
 _kit    = kit;
 _map    = kit->map();   // preserve the map
 _sp     = kit->sp();
 kit->set_map(clone_map ? kit->clone_map() : NULL);
-Compile::current()->inc_preserve_jvm_state();
 #ifdef ASSERT
 _bci    = kit->bci();
 Parse* parser = kit->is_Parse();
 int block = (parser == NULL || parser->block() == NULL) ? -1 : parser->block()->rpo();
 _block  = block;
 int block = (parser == NULL || parser->block() == NULL) ? -1 : parser->block()->rpo();
 assert(block == _block,    "block must not shift");
 #endif
 kit->set_map(_map);
 kit->set_sp(_sp);
-Compile::current()->dec_preserve_jvm_state();
 }
 //-----------------------------BuildCutout-------------------------------------
 BuildCutout::BuildCutout(GraphKit* kit, Node* p, float prob, float cnt)
 Node* GraphKit::load_object_klass(Node* obj) {
 // Special-case a fresh allocation to avoid building nodes:
 Node* akls = AllocateNode::Ideal_klass(obj, &_gvn);
 if (akls != NULL)  return akls;
 Node* k_adr = basic_plus_adr(obj, oopDesc::klass_offset_in_bytes());
-return _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), k_adr, TypeInstPtr::KLASS) );
+return _gvn.transform(LoadKlassNode::make(_gvn, NULL, immutable_memory(), k_adr, TypeInstPtr::KLASS));
 }
 //-------------------------load_array_length-----------------------------------
 Node* GraphKit::load_array_length(Node* array) {
 // Special-case a fresh allocation to avoid building nodes:
 // Note: This operation potentially replaces any edge
 // on the map.  This includes locals, stack, and monitors
 // of the current (innermost) JVM state.
-if (!ReplaceInParentMaps) {
+// don't let inconsistent types from profiling escape this
+// method
+const Type* told = _gvn.type(old);
+const Type* tnew = _gvn.type(neww);
+if (!tnew->higher_equal(told)) {
 return;
 }
-// PreserveJVMState doesn't do a deep copy so we can't modify
+map()->record_replaced_node(old, neww);
-// parents
-if (Compile::current()->has_preserve_jvm_state()) {
-return;
-}
-Parse* parser = is_Parse();
-bool progress = true;
-Node* ctrl = map()->in(0);
-// Follow the chain of parsers and see whether the update can be
-// done in the map of callers. We can do the replace for a caller if
-// the current control post dominates the control of a caller.
-while (parser != NULL && parser->caller() != NULL && progress) {
-progress = false;
-Node* parent_map = parser->caller()->map();
-assert(parser->exits().map()->jvms()->depth() == parser->caller()->depth(), "map mismatch");
-Node* parent_ctrl = parent_map->in(0);
-while (parent_ctrl->is_Region()) {
-Node* n = parent_ctrl->as_Region()->is_copy();
-if (n == NULL) {
-break;
-}
-parent_ctrl = n;
-}
-for (;;) {
-if (ctrl == parent_ctrl) {
-// update the map of the exits which is the one that will be
-// used when compilation resume after inlining
-parser->exits().map()->replace_edge(old, neww);
-progress = true;
-break;
-}
-if (ctrl->is_Proj() && ctrl->as_Proj()->is_uncommon_trap_if_pattern(Deoptimization::Reason_none)) {
-ctrl = ctrl->in(0)->in(0);
-} else if (ctrl->is_Region()) {
-Node* n = ctrl->as_Region()->is_copy();
-if (n == NULL) {
-break;
-}
-ctrl = n;
-} else {
-break;
-}
-}
-parser = parser->parent_parser();
-}
 }
 //=============================================================================
 //--------------------------------memory---------------------------------------
 }
 }
 // Replace the call with the current state of the kit.
-void GraphKit::replace_call(CallNode* call, Node* result) {
+void GraphKit::replace_call(CallNode* call, Node* result, bool do_replaced_nodes) {
 JVMState* ejvms = NULL;
 if (has_exceptions()) {
 ejvms = transfer_exceptions_into_jvms();
 }
+ReplacedNodes replaced_nodes = map()->replaced_nodes();
+ReplacedNodes replaced_nodes_exception;
+Node* ex_ctl = top();
 SafePointNode* final_state = stop();
 // Find all the needed outputs of this call
 CallProjections callprojs;
 // Replace all the old call edges with the edges from the inlining result
 if (callprojs.fallthrough_catchproj != NULL) {
 C->gvn_replace_by(callprojs.fallthrough_catchproj, final_ctl);
 }
 if (callprojs.fallthrough_memproj != NULL) {
+if (final_mem->is_MergeMem()) {
+// Parser's exits MergeMem was not transformed but may be optimized
+final_mem = _gvn.transform(final_mem);
+}
 C->gvn_replace_by(callprojs.fallthrough_memproj,   final_mem);
 }
 if (callprojs.fallthrough_ioproj != NULL) {
 C->gvn_replace_by(callprojs.fallthrough_ioproj,    final_io);
 }
 } else {
 GraphKit ekit(ejvms);
 // Load my combined exception state into the kit, with all phis transformed:
 SafePointNode* ex_map = ekit.combine_and_pop_all_exception_states();
+replaced_nodes_exception = ex_map->replaced_nodes();
 Node* ex_oop = ekit.use_exception_state(ex_map);
 if (callprojs.catchall_catchproj != NULL) {
 C->gvn_replace_by(callprojs.catchall_catchproj, ekit.control());
+ex_ctl = ekit.control();
 }
 if (callprojs.catchall_memproj != NULL) {
 C->gvn_replace_by(callprojs.catchall_memproj,   ekit.reset_memory());
 }
 if (callprojs.catchall_ioproj != NULL) {
 }
 }
 while (wl.size()  > 0) {
 _gvn.transform(wl.pop());
 }
+}
+if (callprojs.fallthrough_catchproj != NULL && !final_ctl->is_top() && do_replaced_nodes) {
+replaced_nodes.apply(C, final_ctl);
+}
+if (!ex_ctl->is_top() && do_replaced_nodes) {
+replaced_nodes_exception.apply(C, ex_ctl);
 }
 }
 //------------------------------increment_counter------------------------------
 for (MergeMemStream mms(merged_memory(), new_mem->as_MergeMem()); mms.next_non_empty2(); ) {
 Node* old_slice = mms.force_memory();
 Node* new_slice = mms.memory2();
 if (old_slice != new_slice) {
 PhiNode* phi;
-if (new_slice->is_Phi() && new_slice->as_Phi()->region() == region) {
+if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region) {
-phi = new_slice->as_Phi();
+if (mms.is_empty()) {
-#ifdef ASSERT
+// clone base memory Phi's inputs for this memory slice
-if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region)
+assert(old_slice == mms.base_memory(), "sanity");
-old_slice = old_slice->in(new_path);
+phi = PhiNode::make(region, NULL, Type::MEMORY, mms.adr_type(C));
-// Caller is responsible for ensuring that any pre-existing
+_gvn.set_type(phi, Type::MEMORY);
-// phis are already aware of old memory.
+for (uint i = 1; i < phi->req(); i++) {
-int old_path = (new_path > 1) ? 1 : 2;  // choose old_path != new_path
+phi->init_req(i, old_slice->in(i));
-assert(phi->in(old_path) == old_slice, "pre-existing phis OK");
+}
-#endif
+} else {
-mms.set_memory(phi);
+phi = old_slice->as_Phi(); // Phi was generated already
+}
 } else {
 phi = PhiNode::make(region, old_slice, Type::MEMORY, mms.adr_type(C));
 _gvn.set_type(phi, Type::MEMORY);
-phi->set_req(new_path, new_slice);
-mms.set_memory(_gvn.transform(phi));  // assume it is complete
 }
+phi->set_req(new_path, new_slice);
+mms.set_memory(phi);
 }
 }
 }
 //------------------------------make_slow_call_ex------------------------------
 Node *p2 = _gvn.transform( new (C) AddPNode(subklass,subklass,chk_off_X) );
 // For some types like interfaces the following loadKlass is from a 1-word
 // cache which is mutable so can't use immutable memory.  Other
 // types load from the super-class display table which is immutable.
 Node *kmem = might_be_cache ? memory(p2) : immutable_memory();
-Node *nkls = _gvn.transform( LoadKlassNode::make( _gvn, kmem, p2, _gvn.type(p2)->is_ptr(), TypeKlassPtr::OBJECT_OR_NULL ) );
+Node* nkls = _gvn.transform(LoadKlassNode::make(_gvn, NULL, kmem, p2, _gvn.type(p2)->is_ptr(), TypeKlassPtr::OBJECT_OR_NULL));
 // Compile speed common case: ARE a subtype and we canNOT fail
 if( superklass == nkls )
 return top();             // false path is dead; no test needed.

Mercurial > hg > truffle

comparison src/share/vm/opto/graphKit.cpp @ 20804:7848fc12602b