jdk-sandbox: comparison hotspot/src/share/vm/opto/buildOopMap.cpp

equal deleted inserted replaced

-:eccb1e520c66
+:49d6711171e6
 // practice.  One array will map to a reaching def Node (or NULL for
 // conflict/dead).  The other array will map to a callee-saved register or
 // OptoReg::Bad for not-callee-saved.
-//------------------------------OopFlow----------------------------------------
 // Structure to pass around
 struct OopFlow : public ResourceObj {
 short *_callees;              // Array mapping register to callee-saved
 Node **_defs;                 // array mapping register to reaching def
 // or NULL if dead/conflict
 // Build an oopmap from the current flow info
 OopMap *build_oop_map( Node *n, int max_reg, PhaseRegAlloc *regalloc, int* live );
 };
-//------------------------------compute_reach----------------------------------
 // Given reaching-defs for this block start, compute it for this block end
 void OopFlow::compute_reach( PhaseRegAlloc *regalloc, int max_reg, Dict *safehash ) {
 for( uint i=0; i<_b->_nodes.size(); i++ ) {
 Node *n = _b->_nodes[i];
 }
 }
 }
 }
-//------------------------------merge------------------------------------------
 // Merge the given flow into the 'this' flow
 void OopFlow::merge( OopFlow *flow, int max_reg ) {
 assert( _b == NULL, "merging into a happy flow" );
 assert( flow->_b, "this flow is still alive" );
 assert( flow != this, "no self flow" );
 _defs[i] = NULL;
 }
 }
-//------------------------------clone------------------------------------------
 void OopFlow::clone( OopFlow *flow, int max_size ) {
 _b = flow->_b;
 memcpy( _callees, flow->_callees, sizeof(short)*max_size);
 memcpy( _defs   , flow->_defs   , sizeof(Node*)*max_size);
 }
-//------------------------------make-------------------------------------------
 OopFlow *OopFlow::make( Arena *A, int max_size, Compile* C ) {
 short *callees = NEW_ARENA_ARRAY(A,short,max_size+1);
 Node **defs    = NEW_ARENA_ARRAY(A,Node*,max_size+1);
 debug_only( memset(defs,0,(max_size+1)*sizeof(Node*)) );
 OopFlow *flow = new (A) OopFlow(callees+1, defs+1, C);
 assert( &flow->_callees[OptoReg::Bad] == callees, "Ok to index at OptoReg::Bad" );
 assert( &flow->_defs   [OptoReg::Bad] == defs   , "Ok to index at OptoReg::Bad" );
 return flow;
 }
-//------------------------------bit twiddlers----------------------------------
 static int get_live_bit( int *live, int reg ) {
 return live[reg>>LogBitsPerInt] &   (1<<(reg&(BitsPerInt-1))); }
 static void set_live_bit( int *live, int reg ) {
 live[reg>>LogBitsPerInt] |=  (1<<(reg&(BitsPerInt-1))); }
 static void clr_live_bit( int *live, int reg ) {
 live[reg>>LogBitsPerInt] &= ~(1<<(reg&(BitsPerInt-1))); }
-//------------------------------build_oop_map----------------------------------
 // Build an oopmap from the current flow info
 OopMap *OopFlow::build_oop_map( Node *n, int max_reg, PhaseRegAlloc *regalloc, int* live ) {
 int framesize = regalloc->_framesize;
 int max_inarg_slot = OptoReg::reg2stack(regalloc->_matcher._new_SP);
 debug_only( char *dup_check = NEW_RESOURCE_ARRAY(char,OptoReg::stack0());
 #endif
 return omap;
 }
-//------------------------------do_liveness------------------------------------
 // Compute backwards liveness on registers
-static void do_liveness( PhaseRegAlloc *regalloc, PhaseCFG *cfg, Block_List *worklist, int max_reg_ints, Arena *A, Dict *safehash ) {
+static void do_liveness(PhaseRegAlloc* regalloc, PhaseCFG* cfg, Block_List* worklist, int max_reg_ints, Arena* A, Dict* safehash) {
-int *live = NEW_ARENA_ARRAY(A, int, (cfg->_num_blocks+1) * max_reg_ints);
+int* live = NEW_ARENA_ARRAY(A, int, (cfg->number_of_blocks() + 1) * max_reg_ints);
-int *tmp_live = &live[cfg->_num_blocks * max_reg_ints];
+int* tmp_live = &live[cfg->number_of_blocks() * max_reg_ints];
-Node *root = cfg->C->root();
+Node* root = cfg->get_root_node();
 // On CISC platforms, get the node representing the stack pointer  that regalloc
 // used for spills
 Node *fp = NodeSentinel;
 if (UseCISCSpill && root->req() > 1) {
 fp = root->in(1)->in(TypeFunc::FramePtr);
 }
-memset( live, 0, cfg->_num_blocks * (max_reg_ints<<LogBytesPerInt) );
+memset(live, 0, cfg->number_of_blocks() * (max_reg_ints << LogBytesPerInt));
 // Push preds onto worklist
 for (uint i = 1; i < root->req(); i++) {
 Block* block = cfg->get_block_for_node(root->in(i));
 worklist->push(block);
 }
 }
 // Scan for any missing safepoints.  Happens to infinite loops
 // ala ZKM.jar
 uint i;
-for( i=1; i<cfg->_num_blocks; i++ ) {
+for (i = 1; i < cfg->number_of_blocks(); i++) {
-Block *b = cfg->_blocks[i];
+Block* block = cfg->get_block(i);
 uint j;
-for( j=1; j<b->_nodes.size(); j++ )
+for (j = 1; j < block->_nodes.size(); j++) {
-if( b->_nodes[j]->jvms() &&
+if (block->_nodes[j]->jvms() && (*safehash)[block->_nodes[j]] == NULL) {
-(*safehash)[b->_nodes[j]] == NULL )
 break;
-if( j<b->_nodes.size() ) break;
+}
 }
-if( i == cfg->_num_blocks )
+if (j < block->_nodes.size()) {
+break;
+}
+}
+if (i == cfg->number_of_blocks()) {
 break;                    // Got 'em all
+}
 #ifndef PRODUCT
 if( PrintOpto && Verbose )
 tty->print_cr("retripping live calc");
 #endif
 // Force the issue (expensively): recheck everybody
-for( i=1; i<cfg->_num_blocks; i++ )
+for (i = 1; i < cfg->number_of_blocks(); i++) {
-worklist->push(cfg->_blocks[i]);
+worklist->push(cfg->get_block(i));
 }
+}
 }
-//------------------------------BuildOopMaps-----------------------------------
 // Collect GC mask info - where are all the OOPs?
 void Compile::BuildOopMaps() {
 NOT_PRODUCT( TracePhase t3("bldOopMaps", &_t_buildOopMaps, TimeCompiler); )
 // Can't resource-mark because I need to leave all those OopMaps around,
 // or else I need to resource-mark some arena other than the default.
 safehash = new Dict(cmpkey,hashkey,A);
 do_liveness( _regalloc, _cfg, &worklist, max_reg_ints, A, safehash );
 OopFlow *free_list = NULL;    // Free, unused
 // Array mapping blocks to completed oopflows
-OopFlow **flows = NEW_ARENA_ARRAY(A, OopFlow*, _cfg->_num_blocks);
+OopFlow **flows = NEW_ARENA_ARRAY(A, OopFlow*, _cfg->number_of_blocks());
-memset( flows, 0, _cfg->_num_blocks*sizeof(OopFlow*) );
+memset( flows, 0, _cfg->number_of_blocks() * sizeof(OopFlow*) );
 // Do the first block 'by hand' to prime the worklist
-Block *entry = _cfg->_blocks[1];
+Block *entry = _cfg->get_block(1);
 OopFlow *rootflow = OopFlow::make(A,max_reg,this);
 // Initialize to 'bottom' (not 'top')
 memset( rootflow->_callees, OptoReg::Bad, max_reg*sizeof(short) );
 memset( rootflow->_defs   ,            0, max_reg*sizeof(Node*) );
 flows[entry->_pre_order] = rootflow;
 // SAME reaching def for the block, so any reaching def is OK.
 uint i;
 Block *b = worklist.pop();
 // Ignore root block
-if( b == _cfg->_broot ) continue;
+if (b == _cfg->get_root_block()) {
+continue;
+}
 // Block is already done?  Happens if block has several predecessors,
 // he can get on the worklist more than once.
 if( flows[b->_pre_order] ) continue;
 // If this block has a visited predecessor AND that predecessor has this

changeset 19330	49d6711171e6
parent 19279	4be3c2e6663c
child 19717	7819ffdaf0ff