graal-jvmci-8: src/share/vm/opto/chaitin.cpp comparison

comparison src/share/vm/opto/chaitin.cpp @ 14422:2b8e28fdf503

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	8c83625e3a53
children	303c352ba1a8 15120a36272d

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 return score + 1e10;        // Likely no progress to spill
 return score;
 }
-LRG_List::LRG_List( uint max ) : _cnt(max), _max(max), _lidxs(NEW_RESOURCE_ARRAY(uint,max)) {
-memset( _lidxs, 0, sizeof(uint)*max );
-}
-void LRG_List::extend( uint nidx, uint lidx ) {
-_nesting.check();
-if( nidx >= _max ) {
-uint size = 16;
-while( size <= nidx ) size <<=1;
-_lidxs = REALLOC_RESOURCE_ARRAY( uint, _lidxs, _max, size );
-_max = size;
-}
-while( _cnt <= nidx )
-_lidxs[_cnt++] = 0;
-_lidxs[nidx] = lidx;
-}
 #define NUMBUCKS 3
 // Straight out of Tarjan's union-find algorithm
 uint LiveRangeMap::find_compress(uint lrg) {
 uint cur = lrg;
-uint next = _uf_map[cur];
+uint next = _uf_map.at(cur);
 while (next != cur) { // Scan chain of equivalences
 assert( next < cur, "always union smaller");
 cur = next; // until find a fixed-point
-next = _uf_map[cur];
+next = _uf_map.at(cur);
 }
 // Core of union-find algorithm: update chain of
 // equivalences to be equal to the root.
 while (lrg != next) {
-uint tmp = _uf_map[lrg];
+uint tmp = _uf_map.at(lrg);
-_uf_map.map(lrg, next);
+_uf_map.at_put(lrg, next);
 lrg = tmp;
 }
 return lrg;
 }
 // Reset the Union-Find map to identity
 void LiveRangeMap::reset_uf_map(uint max_lrg_id) {
 _max_lrg_id= max_lrg_id;
 // Force the Union-Find mapping to be at least this large
-_uf_map.extend(_max_lrg_id, 0);
+_uf_map.at_put_grow(_max_lrg_id, 0);
 // Initialize it to be the ID mapping.
 for (uint i = 0; i < _max_lrg_id; ++i) {
-_uf_map.map(i, i);
+_uf_map.at_put(i, i);
 }
 }
 // Make all Nodes map directly to their final live range; no need for
 // the Union-Find mapping after this call.
 void LiveRangeMap::compress_uf_map_for_nodes() {
 // For all Nodes, compress mapping
-uint unique = _names.Size();
+uint unique = _names.length();
 for (uint i = 0; i < unique; ++i) {
-uint lrg = _names[i];
+uint lrg = _names.at(i);
 uint compressed_lrg = find(lrg);
 if (lrg != compressed_lrg) {
-_names.map(i, compressed_lrg);
+_names.at_put(i, compressed_lrg);
 }
 }
 }
 // Like Find above, but no path compress, so bad asymptotic behavior
 // brand new live ranges but have not told the allocator yet.
 if (lrg >= _max_lrg_id) {
 return lrg;
 }
-uint next = _uf_map[lrg];
+uint next = _uf_map.at(lrg);
 while (next != lrg) { // Scan chain of equivalences
 assert(next < lrg, "always union smaller");
 lrg = next; // until find a fixed-point
-next = _uf_map[lrg];
+next = _uf_map.at(lrg);
 }
 return next;
 }
 PhaseChaitin::PhaseChaitin(uint unique, PhaseCFG &cfg, Matcher &matcher)
 print_chaitin_statistics
 #else
 NULL
 #endif
 )
-, _lrg_map(unique)
+, _lrg_map(Thread::current()->resource_area(), unique)
 , _live(0)
 , _spilled_once(Thread::current()->resource_area())
 , _spilled_twice(Thread::current()->resource_area())
 , _lo_degree(0), _lo_stk_degree(0), _hi_degree(0), _simplified(0)
 , _oldphi(unique)
 assert(_cfg.get_block_for_node(proj) == borig, "incorrect block for kill projections");
 found_projs++;
 // Copy kill projections after the cloned node
 Node* kills = proj->clone();
 kills->set_req(0, copy);
-b->_nodes.insert(idx++, kills);
+b->insert_node(kills, idx++);
 _cfg.map_node_to_block(kills, b);
 new_lrg(kills, max_lrg_id++);
 }
 }
 return found_projs;
 // get allocated, but instead rely on correct scheduling to ensure that
 // only one instance is simultaneously live at a time.
 uint lr_counter = 1;
 for( uint i = 0; i < _cfg.number_of_blocks(); i++ ) {
 Block* block = _cfg.get_block(i);
-uint cnt = block->_nodes.size();
+uint cnt = block->number_of_nodes();
 // Handle all the normal Nodes in the block
 for( uint j = 0; j < cnt; j++ ) {
-Node *n = block->_nodes[j];
+Node *n = block->get_node(j);
 // Pre-color to the zero live range, or pick virtual register
 const RegMask &rm = n->out_RegMask();
 _lrg_map.map(n->_idx, rm.is_NotEmpty() ? lr_counter++ : 0);
 }
 }
 // Reset the Union-Find mapping to be identity
 _lrg_map.reset_uf_map(lr_counter);
 }
 // For all blocks
 for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
 Block* block = _cfg.get_block(i);
 // For all instructions
-for (uint j = 1; j < block->_nodes.size(); j++) {
+for (uint j = 1; j < block->number_of_nodes(); j++) {
-Node* n = block->_nodes[j];
+Node* n = block->get_node(j);
 uint input_edge_start =1; // Skip control most nodes
 if (n->is_Mach()) {
 input_edge_start = n->as_Mach()->oper_input_base();
 }
 uint idx = n->is_Copy();
 Block* block = _cfg.get_block(i);
 // For all instructions in block
 uint last_inst = block->end_idx();
 for (uint j = 1; j <= last_inst; j++) {
-Node* n = block->_nodes[j];
+Node* n = block->get_node(j);
 // Dead instruction???
 assert( n->outcnt() != 0 ||// Nothing dead after post alloc
 C->top() == n ||  // Or the random TOP node
 n->is_Proj(),     // Or a fat-proj kill node
 cisc->set_req(inp,fp);          // Base register is frame pointer
 if( cisc->oper_input_base() > 1 && mach->oper_input_base() <= 1 ) {
 assert( cisc->oper_input_base() == 2, "Only adding one edge");
 cisc->ins_req(1,src);         // Requires a memory edge
 }
-block->_nodes.map(j,cisc);          // Insert into basic block
+block->map_node(cisc, j);          // Insert into basic block
 n->subsume_by(cisc, C); // Correct graph
 //
 ++_used_cisc_instructions;
 #ifndef PRODUCT
 if( TraceCISCSpill ) {
 // Initialize it once and make it shared:
 // set control to _root and place it into Start block
 // (where top() node is placed).
 base->init_req(0, _cfg.get_root_node());
 Block *startb = _cfg.get_block_for_node(C->top());
-startb->_nodes.insert(startb->find_node(C->top()), base );
+startb->insert_node(base, startb->find_node(C->top()));
 _cfg.map_node_to_block(base, startb);
 assert(_lrg_map.live_range_id(base) == 0, "should not have LRG yet");
 }
 if (_lrg_map.live_range_id(base) == 0) {
 new_lrg(base, maxlrg++);
 base->as_Phi()->set_type(t);
 // Search the current block for an existing base-Phi
 Block *b = _cfg.get_block_for_node(derived);
 for( i = 1; i <= b->end_idx(); i++ ) {// Search for matching Phi
-Node *phi = b->_nodes[i];
+Node *phi = b->get_node(i);
 if( !phi->is_Phi() ) {      // Found end of Phis with no match?
-b->_nodes.insert( i, base ); // Must insert created Phi here as base
+b->insert_node(base,  i); // Must insert created Phi here as base
 _cfg.map_node_to_block(base, b);
 new_lrg(base,maxlrg++);
 break;
 }
 // See if Phi matches.
 // Note use of deep-copy constructor.  I cannot hammer the original
 // liveout bits, because they are needed by the following coalesce pass.
 IndexSet liveout(_live->live(block));
 for (uint j = block->end_idx() + 1; j > 1; j--) {
-Node* n = block->_nodes[j - 1];
+Node* n = block->get_node(j - 1);
 // Pre-split compares of loop-phis.  Loop-phis form a cycle we would
 // like to see in the same register.  Compare uses the loop-phi and so
 // extends its live range BUT cannot be part of the cycle.  If this
 // extended live range overlaps with the update of the loop-phi value
 void PhaseChaitin::dump(const Block *b) const {
 b->dump_head(&_cfg);
 // For all instructions
-for( uint j = 0; j < b->_nodes.size(); j++ )
+for( uint j = 0; j < b->number_of_nodes(); j++ )
-dump(b->_nodes[j]);
+dump(b->get_node(j));
 // Print live-out info at end of block
 if( _live ) {
 tty->print("Liveout: ");
 IndexSet *live = _live->live(b);
 IndexSetIterator elements(live);
 for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
 Block* block = _cfg.get_block(i);
 int dump_once = 0;
 // For all instructions
-for( uint j = 0; j < block->_nodes.size(); j++ ) {
+for( uint j = 0; j < block->number_of_nodes(); j++ ) {
-Node *n = block->_nodes[j];
+Node *n = block->get_node(j);
 if (_lrg_map.find_const(n) == lidx) {
 if (!dump_once++) {
 tty->cr();
 block->dump_head(&_cfg);
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/chaitin.cpp @ 14422:2b8e28fdf503