jdk8-mips64-public/hotspot: comparison src/share/vm/opto/cfgnode.cpp

-:ec59443af135
+:98cb887364d3
 n->del_req(i);
 }
 }
 // Register the new node but do not transform it.  Cannot transform until the
-// entire Region/Phi conglerate has been hacked as a single huge transform.
+// entire Region/Phi conglomerate has been hacked as a single huge transform.
 igvn->register_new_node_with_optimizer( newn );
 // Now I can point to the new node.
 n->add_req(newn);
 igvn->_worklist.push(n);
 }
 return NULL;
 Node *val = phi->in(i);       // Constant to split for
 uint hit = 0;                 // Number of times it occurs
-for( ; i < phi->req(); i++ ){ // Count occurances of constant
+for( ; i < phi->req(); i++ ){ // Count occurrences of constant
 Node *n = phi->in(i);
 if( !n ) return NULL;
 if( phase->type(n) == Type::TOP ) return NULL;
 if( phi->in(i) == val )
 hit++;
 return phi;
 }
 //=============================================================================
 //------------------------------simple_data_loop_check-------------------------
-//  Try to determing if the phi node in a simple safe/unsafe data loop.
+//  Try to determining if the phi node in a simple safe/unsafe data loop.
 //  Returns:
 // enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop };
 // Safe       - safe case when the phi and it's inputs reference only safe data
 //              nodes;
 // Unsafe     - the phi and it's inputs reference unsafe data nodes but there
 Node *m  = phase->transform(n);
 if (outcnt() == 0) {  // Above transform() may kill us!
 progress = phase->C->top();
 break;
 }
-// If tranformed to a MergeMem, get the desired slice
+// If transformed to a MergeMem, get the desired slice
 // Otherwise the returned node represents memory for every slice
 Node *new_mem = (m->is_MergeMem()) ?
 m->as_MergeMem()->memory_at(alias_idx) : m;
 // Update input if it is progress over what we have now
 if (new_mem != ii) {
 // Rethrows always throw exceptions, never return
 if (call->entry_point() == OptoRuntime::rethrow_stub()) {
 f[CatchProjNode::fall_through_index] = Type::TOP;
 } else if( call->req() > TypeFunc::Parms ) {
 const Type *arg0 = phase->type( call->in(TypeFunc::Parms) );
-// Check for null reciever to virtual or interface calls
+// Check for null receiver to virtual or interface calls
 if( call->is_CallDynamicJava() &&
 arg0->higher_equal(TypePtr::NULL_PTR) ) {
 f[CatchProjNode::fall_through_index] = Type::TOP;
 }
 } // End of if not a runtime stub
 if (t->field_at(_con) != Type::CONTROL)  return this;
 // If we remove the last CatchProj and elide the Catch/CatchProj, then we
 // also remove any exception table entry.  Thus we must know the call
 // feeding the Catch will not really throw an exception.  This is ok for
 // the main fall-thru control (happens when we know a call can never throw
-// an exception) or for "rethrow", because a further optimnization will
+// an exception) or for "rethrow", because a further optimization will
 // yank the rethrow (happens when we inline a function that can throw an
 // exception and the caller has no handler).  Not legal, e.g., for passing
 // a NULL receiver to a v-call, or passing bad types to a slow-check-cast.
 // These cases MUST throw an exception via the runtime system, so the VM
 // will be looking for a table entry.

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/cfgnode.cpp

src/share/vm/opto/cfgnode.cpp