Refactor allocation policies.

src/safepoint-table.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 103 matching lines @@
     PrintF("%c", ((byte & (1 << i)) == 0) ? '0' : '1');
   }
 }
 
 
 void Safepoint::DefinePointerRegister(Register reg) {
   registers_->Add(reg.code());
 }
 
 
+SafepointTableBuilder::SafepointTableBuilder() : deoptimization_info_(ZONE, 32),
+                                                 indexes_(ZONE, 32),
+                                                 registers_(ZONE, 32),
+                                                 emitted_(false) { }
+
+
 Safepoint SafepointTableBuilder::DefineSafepoint(
     Assembler* assembler, Safepoint::Kind kind, int arguments,
     int deoptimization_index) {
   ASSERT(deoptimization_index != -1);
   ASSERT(arguments >= 0);
   DeoptimizationInfo pc_and_deoptimization_index;
   pc_and_deoptimization_index.pc = assembler->pc_offset();
   pc_and_deoptimization_index.deoptimization_index = deoptimization_index;
   pc_and_deoptimization_index.pc_after_gap = assembler->pc_offset();
   pc_and_deoptimization_index.arguments = arguments;
   pc_and_deoptimization_index.has_doubles = (kind & Safepoint::kWithDoubles);
   deoptimization_info_.Add(pc_and_deoptimization_index);
-  indexes_.Add(new ZoneList<int>(8));
+  indexes_.Add(ZoneList<int>::New(ZONE, 8));
   registers_.Add((kind & Safepoint::kWithRegisters)
-      ? new ZoneList<int>(4)
-      : NULL);
+                 ? ZoneList<int>::New(ZONE, 4)
+                 : NULL);
   return Safepoint(indexes_.last(), registers_.last());
 }
 
 
 unsigned SafepointTableBuilder::GetCodeOffset() const {
   ASSERT(emitted_);
   return offset_;
 }
 
 
@@ skipping 24 matching lines @@
   assembler->dd(bytes_per_entry);
 
   // Emit sorted table of pc offsets together with deoptimization indexes and
   // pc after gap information.
   for (int i = 0; i < length; i++) {
     assembler->dd(deoptimization_info_[i].pc);
     assembler->dd(EncodeExceptPC(deoptimization_info_[i]));
   }
 
   // Emit table of bitmaps.
-  ZoneList<uint8_t> bits(bytes_per_entry);
+  ZoneList<uint8_t> bits(ZONE, bytes_per_entry);
   for (int i = 0; i < length; i++) {
     ZoneList<int>* indexes = indexes_[i];
     ZoneList<int>* registers = registers_[i];
     bits.Clear();
     bits.AddBlock(0, bytes_per_entry);
 
     // Run through the registers (if any).
     ASSERT(IsAligned(kNumSafepointRegisters, kBitsPerByte));
     if (registers == NULL) {
       const int num_reg_bytes = kNumSafepointRegisters >> kBitsPerByteLog2;
@@ skipping 52 matching lines @@
         previous_gap_end = info.pc_after_gap;
       }
     }
   }
   return result;
 }
 
 
 
 } }  // namespace v8::internal