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

-:3068270ba476
+:2b8e28fdf503
 // Find trailing Region
 Block *pb = get_block_for_node(in0); // Block-projection already has basic block
 uint j = 0;
 if (pb->_num_succs != 1) {  // More then 1 successor?
 // Search for successor
-uint max = pb->_nodes.size();
+uint max = pb->number_of_nodes();
 assert( max > 1, "" );
 uint start = max - pb->_num_succs;
 // Find which output path belongs to projection
 for (j = start; j < max; j++) {
-if( pb->_nodes[j] == in0 )
+if( pb->get_node(j) == in0 )
 break;
 }
 assert( j < max, "must find" );
 // Change control to match head of successor basic block
 j -= start;
 Block* PhaseCFG::hoist_to_cheaper_block(Block* LCA, Block* early, Node* self) {
 const double delta = 1+PROB_UNLIKELY_MAG(4);
 Block* least       = LCA;
 double least_freq  = least->_freq;
 uint target        = get_latency_for_node(self);
-uint start_latency = get_latency_for_node(LCA->_nodes[0]);
+uint start_latency = get_latency_for_node(LCA->head());
-uint end_latency   = get_latency_for_node(LCA->_nodes[LCA->end_idx()]);
+uint end_latency   = get_latency_for_node(LCA->get_node(LCA->end_idx()));
 bool in_latency    = (target <= start_latency);
 const Block* root_block = get_block_for_node(_root);
 // Turn off latency scheduling if scheduling is just plain off
 if (!C->do_scheduling())
 if (trace_opto_pipelining()) {
 tty->print("# Find cheaper block for latency %d: ", get_latency_for_node(self));
 self->dump();
 tty->print_cr("#   B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g",
 LCA->_pre_order,
-LCA->_nodes[0]->_idx,
+LCA->head()->_idx,
 start_latency,
-LCA->_nodes[LCA->end_idx()]->_idx,
+LCA->get_node(LCA->end_idx())->_idx,
 end_latency,
 least_freq);
 }
 #endif
 // Don't hoist machine instructions to the root basic block
 if (mach && LCA == root_block)
 break;
-uint start_lat = get_latency_for_node(LCA->_nodes[0]);
+uint start_lat = get_latency_for_node(LCA->head());
 uint end_idx   = LCA->end_idx();
-uint end_lat   = get_latency_for_node(LCA->_nodes[end_idx]);
+uint end_lat   = get_latency_for_node(LCA->get_node(end_idx));
 double LCA_freq = LCA->_freq;
 #ifndef PRODUCT
 if (trace_opto_pipelining()) {
 tty->print_cr("#   B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g",
-LCA->_pre_order, LCA->_nodes[0]->_idx, start_lat, end_idx, end_lat, LCA_freq);
+LCA->_pre_order, LCA->head()->_idx, start_lat, end_idx, end_lat, LCA_freq);
 }
 #endif
 cand_cnt++;
 if (LCA_freq < least_freq              || // Better Frequency
 (StressGCM && Compile::randomized_select(cand_cnt)) || // Should be randomly accepted in stress mode
 // for( int i=0; i < (int)matcher._null_check_tests.size(); i+=2 ) {
 for (int i = _matcher._null_check_tests.size() - 2; i >= 0; i -= 2) {
 Node* proj = _matcher._null_check_tests[i];
 Node* val  = _matcher._null_check_tests[i + 1];
 Block* block = get_block_for_node(proj);
-block->implicit_null_check(this, proj, val, allowed_reasons);
+implicit_null_check(block, proj, val, allowed_reasons);
 // The implicit_null_check will only perform the transformation
 // if the null branch is truly uncommon, *and* it leads to an
 // uncommon trap.  Combined with the too_many_traps guards
 // above, this prevents SEGV storms reported in 6366351,
 // by recompiling offending methods without this optimization.
 // Later, do a real latency aware scheduler.
 GrowableArray<int> ready_cnt(C->unique(), C->unique(), -1);
 visited.Clear();
 for (uint i = 0; i < number_of_blocks(); i++) {
 Block* block = get_block(i);
-if (!block->schedule_local(this, _matcher, ready_cnt, visited)) {
+if (!schedule_local(block, ready_cnt, visited)) {
 if (!C->failure_reason_is(C2Compiler::retry_no_subsuming_loads())) {
 C->record_method_not_compilable("local schedule failed");
 }
 return;
 }
 // If we inserted any instructions between a Call and his CatchNode,
 // clone the instructions on all paths below the Catch.
 for (uint i = 0; i < number_of_blocks(); i++) {
 Block* block = get_block(i);
-block->call_catch_cleanup(this, C);
+call_catch_cleanup(block);
 }
 #ifndef PRODUCT
 if (trace_opto_pipelining()) {
 tty->print("\n---- After GlobalCodeMotion ----\n");
 //------------------------------succ_prob-------------------------------------
 // Determine the probability of reaching successor 'i' from the receiver block.
 float Block::succ_prob(uint i) {
 int eidx = end_idx();
-Node *n = _nodes[eidx];  // Get ending Node
+Node *n = get_node(eidx);  // Get ending Node
 int op = n->Opcode();
 if (n->is_Mach()) {
 if (n->is_MachNullCheck()) {
 // Can only reach here if called after lcm. The original Op_If is gone,
 assert (i < 2, "just checking");
 // Conditionals pass on only part of their frequency
 float prob  = n->as_MachIf()->_prob;
 assert(prob >= 0.0 && prob <= 1.0, "out of range probability");
 // If succ[i] is the FALSE branch, invert path info
-if( _nodes[i + eidx + 1]->Opcode() == Op_IfFalse ) {
+if( get_node(i + eidx + 1)->Opcode() == Op_IfFalse ) {
 return 1.0f - prob; // not taken
 } else {
 return prob; // taken
 }
 }
 case Op_Jump:
 // Divide the frequency between all successors evenly
 return 1.0f/_num_succs;
 case Op_Catch: {
-const CatchProjNode *ci = _nodes[i + eidx + 1]->as_CatchProj();
+const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
 if (ci->_con == CatchProjNode::fall_through_index) {
 // Fall-thru path gets the lion's share.
 return 1.0f - PROB_UNLIKELY_MAG(5)*_num_succs;
 } else {
 // Presume exceptional paths are equally unlikely
 //------------------------------num_fall_throughs-----------------------------
 // Return the number of fall-through candidates for a block
 int Block::num_fall_throughs() {
 int eidx = end_idx();
-Node *n = _nodes[eidx];  // Get ending Node
+Node *n = get_node(eidx);  // Get ending Node
 int op = n->Opcode();
 if (n->is_Mach()) {
 if (n->is_MachNullCheck()) {
 // In theory, either side can fall-thru, for simplicity sake,
 case Op_Goto:
 return 1;
 case Op_Catch: {
 for (uint i = 0; i < _num_succs; i++) {
-const CatchProjNode *ci = _nodes[i + eidx + 1]->as_CatchProj();
+const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
 if (ci->_con == CatchProjNode::fall_through_index) {
 return 1;
 }
 }
 return 0;
 //------------------------------succ_fall_through-----------------------------
 // Return true if a specific successor could be fall-through target.
 bool Block::succ_fall_through(uint i) {
 int eidx = end_idx();
-Node *n = _nodes[eidx];  // Get ending Node
+Node *n = get_node(eidx);  // Get ending Node
 int op = n->Opcode();
 if (n->is_Mach()) {
 if (n->is_MachNullCheck()) {
 // In theory, either side can fall-thru, for simplicity sake,
 // let's say only the false branch can now.
-return _nodes[i + eidx + 1]->Opcode() == Op_IfFalse;
+return get_node(i + eidx + 1)->Opcode() == Op_IfFalse;
 }
 op = n->as_Mach()->ideal_Opcode();
 }
 // Switch on branch type
 case Op_Root:
 case Op_Goto:
 return true;
 case Op_Catch: {
-const CatchProjNode *ci = _nodes[i + eidx + 1]->as_CatchProj();
+const CatchProjNode *ci = get_node(i + eidx + 1)->as_CatchProj();
 return ci->_con == CatchProjNode::fall_through_index;
 }
 case Op_Jump:
 case Op_NeverBranch:
 //------------------------------update_uncommon_branch------------------------
 // Update the probability of a two-branch to be uncommon
 void Block::update_uncommon_branch(Block* ub) {
 int eidx = end_idx();
-Node *n = _nodes[eidx];  // Get ending Node
+Node *n = get_node(eidx);  // Get ending Node
 int op = n->as_Mach()->ideal_Opcode();
 assert(op == Op_CountedLoopEnd || op == Op_If, "must be a If");
 assert(num_fall_throughs() == 2, "must be a two way branch block");
 }
 assert(s < 2, "uncommon successor must be found");
 // If ub is the true path, make the proability small, else
 // ub is the false path, and make the probability large
-bool invert = (_nodes[s + eidx + 1]->Opcode() == Op_IfFalse);
+bool invert = (get_node(s + eidx + 1)->Opcode() == Op_IfFalse);
 // Get existing probability
 float p = n->as_MachIf()->_prob;
 if (invert) p = 1.0 - p;

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

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

src/share/vm/opto/gcm.cpp