jdk-sandbox: comparison hotspot/src/share/vm/c1/c1

equal deleted inserted replaced

-:4e2bff1a5467
+:b0c9cb06506b
 , _lir_ops(0)     // initialized later with correct length
 , _block_of_op(0) // initialized later with correct length
 , _has_info(0)
 , _has_call(0)
 , _scope_value_cache(0) // initialized later with correct length
-, _interval_in_loop(0, 0) // initialized later with correct length
+, _interval_in_loop(0)  // initialized later with correct length
 , _cached_blocks(*ir->linear_scan_order())
 #ifdef X86
 , _fpu_stack_allocator(NULL)
 #endif
 {
 block->set_last_lir_instruction_id(op_id - 2);
 }
 assert(idx == num_instructions, "must match");
 assert(idx * 2 == op_id, "must match");
-_has_call = BitMap(num_instructions); _has_call.clear();
+_has_call.initialize(num_instructions);
-_has_info = BitMap(num_instructions); _has_info.clear();
+_has_info.initialize(num_instructions);
 }
 // ********** Phase 2: compute local live sets separately for each block
 // (sets live_gen and live_kill for each block)
 // iterate all blocks
 for (int i = 0; i < num_blocks; i++) {
 BlockBegin* block = block_at(i);
-BitMap live_gen(live_size);  live_gen.clear();
+ResourceBitMap live_gen(live_size);  live_gen.clear();
-BitMap live_kill(live_size); live_kill.clear();
+ResourceBitMap live_kill(live_size); live_kill.clear();
 if (block->is_set(BlockBegin::exception_entry_flag)) {
 // Phi functions at the begin of an exception handler are
 // implicitly defined (= killed) at the beginning of the block.
 for_each_phi_fun(block, phi,
 }
 } // end of instruction iteration
 block->set_live_gen (live_gen);
 block->set_live_kill(live_kill);
-block->set_live_in  (BitMap(live_size)); block->live_in().clear();
+block->set_live_in  (ResourceBitMap(live_size)); block->live_in().clear();
-block->set_live_out (BitMap(live_size)); block->live_out().clear();
+block->set_live_out (ResourceBitMap(live_size)); block->live_out().clear();
 TRACE_LINEAR_SCAN(4, tty->print("live_gen  B%d ", block->block_id()); print_bitmap(block->live_gen()));
 TRACE_LINEAR_SCAN(4, tty->print("live_kill B%d ", block->block_id()); print_bitmap(block->live_kill()));
 } // end of block iteration
 int  num_blocks = block_count();
 bool change_occurred;
 bool change_occurred_in_block;
 int  iteration_count = 0;
-BitMap live_out(live_set_size()); live_out.clear(); // scratch set for calculations
+ResourceBitMap live_out(live_set_size()); live_out.clear(); // scratch set for calculations
 // Perform a backward dataflow analysis to compute live_out and live_in for each block.
 // The loop is executed until a fixpoint is reached (no changes in an iteration)
 // Exception handlers must be processed because not all live values are
 // present in the state array, e.g. because of global value numbering
 live_out.set_union(block->exception_handler_at(j)->live_in());
 }
 if (!block->live_out().is_same(live_out)) {
 // A change occurred.  Swap the old and new live out sets to avoid copying.
-BitMap temp = block->live_out();
+ResourceBitMap temp = block->live_out();
 block->set_live_out(live_out);
 live_out = temp;
 change_occurred = true;
 change_occurred_in_block = true;
 }
 if (iteration_count == 0 || change_occurred_in_block) {
 // live_in(block) is the union of live_gen(block) with (live_out(block) & !live_kill(block))
 // note: live_in has to be computed only in first iteration or if live_out has changed!
-BitMap live_in = block->live_in();
+ResourceBitMap live_in = block->live_in();
 live_in.set_from(block->live_out());
 live_in.set_difference(block->live_kill());
 live_in.set_union(block->live_gen());
 }
 }
 }
 #endif
 // check that the live_in set of the first block is empty
-BitMap live_in_args(ir()->start()->live_in().size());
+ResourceBitMap live_in_args(ir()->start()->live_in().size());
 live_in_args.clear();
 if (!ir()->start()->live_in().is_same(live_in_args)) {
 #ifdef ASSERT
 tty->print_cr("Error: live_in set of first block must be empty (when this fails, virtual registers are used before they are defined)");
 tty->print_cr("affected registers:");
 assert(block_from == instructions->at(0)->id(), "must be");
 assert(block_to   == instructions->at(instructions->length() - 1)->id(), "must be");
 // Update intervals for registers live at the end of this block;
-BitMap live = block->live_out();
+ResourceBitMap live = block->live_out();
 int size = (int)live.size();
 for (int number = (int)live.get_next_one_offset(0, size); number < size; number = (int)live.get_next_one_offset(number + 1, size)) {
 assert(live.at(number), "should not stop here otherwise");
 assert(number >= LIR_OprDesc::vreg_base, "fixed intervals must not be live on block bounds");
 TRACE_LINEAR_SCAN(2, tty->print_cr("live in %d to %d", number, block_to + 2));
 void LinearScan::resolve_collect_mappings(BlockBegin* from_block, BlockBegin* to_block, MoveResolver &move_resolver) {
 DEBUG_ONLY(move_resolver.check_empty());
 const int num_regs = num_virtual_regs();
 const int size = live_set_size();
-const BitMap live_at_edge = to_block->live_in();
+const ResourceBitMap live_at_edge = to_block->live_in();
 // visit all registers where the live_at_edge bit is set
 for (int r = (int)live_at_edge.get_next_one_offset(0, size); r < size; r = (int)live_at_edge.get_next_one_offset(r + 1, size)) {
 assert(r < num_regs, "live information set for not exisiting interval");
 assert(from_block->live_out().at(r) && to_block->live_in().at(r), "interval not live at this edge");
 void LinearScan::resolve_data_flow() {
 TIME_LINEAR_SCAN(timer_resolve_data_flow);
 int num_blocks = block_count();
 MoveResolver move_resolver(this);
-BitMap block_completed(num_blocks);  block_completed.clear();
+ResourceBitMap block_completed(num_blocks);  block_completed.clear();
-BitMap already_resolved(num_blocks); already_resolved.clear();
+ResourceBitMap already_resolved(num_blocks); already_resolved.clear();
 int i;
 for (i = 0; i < num_blocks; i++) {
 BlockBegin* block = block_at(i);
 int size = live_set_size();
 int num_blocks = block_count();
 for (int i = 0; i < num_blocks; i++) {
 BlockBegin* block = block_at(i);
-BitMap live_at_edge = block->live_in();
+ResourceBitMap live_at_edge = block->live_in();
 // visit all registers where the live_at_edge bit is set
 for (int r = (int)live_at_edge.get_next_one_offset(0, size); r < size; r = (int)live_at_edge.get_next_one_offset(r + 1, size)) {
 TRACE_LINEAR_SCAN(4, tty->print("checking interval %d of block B%d", r, block->block_id()));
 assert(_mapping_to.at(i) != _mapping_to.at(j), "cannot write to same interval twice");
 }
 }
-BitMap used_regs(LinearScan::nof_regs + allocator()->frame_map()->argcount() + allocator()->max_spills());
+ResourceBitMap used_regs(LinearScan::nof_regs + allocator()->frame_map()->argcount() + allocator()->max_spills());
 used_regs.clear();
 if (!_multiple_reads_allowed) {
 for (i = 0; i < _mapping_from.length(); i++) {
 Interval* it = _mapping_from.at(i);
 if (it != NULL) {
 DEBUG_ONLY(verify(code));
 }
 void ControlFlowOptimizer::delete_jumps_to_return(BlockList* code) {
 #ifdef ASSERT
-BitMap return_converted(BlockBegin::number_of_blocks());
+ResourceBitMap return_converted(BlockBegin::number_of_blocks());
 return_converted.clear();
 #endif
 for (int i = code->length() - 1; i >= 0; i--) {
 BlockBegin* block = code->at(i);

changeset 38177	b0c9cb06506b
parent 38033	996ce936543f
child 38658	34f9c45625d8