Add product mode:

runtime/vm/zone.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/zone.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/handles_impl.h"
 #include "vm/heap.h"
 #include "vm/os.h"
 
 namespace dart {
 
-DEFINE_DEBUG_FLAG(bool, trace_zones,
-                  false, "Traces allocation sizes in the zone.");
-
-
 // Zone segments represent chunks of memory: They have starting
 // address encoded in the this pointer and a size in bytes. They are
 // chained together to form the backing storage for an expanding zone.
 class Zone::Segment {
  public:
   Segment* next() const { return next_; }
   intptr_t size() const { return size_; }
 
   uword start() { return address(sizeof(Segment)); }
   uword end() { return address(size_); }
@@ skipping 78 matching lines @@
   }
   size += initial_buffer_.size();
   for (Segment* s = head_->next(); s != NULL; s = s->next()) {
     size += s->size();
   }
   return size + (position_ - head_->start());
 }
 
 
 uword Zone::AllocateExpand(intptr_t size) {
-#if defined(DEBUG)
   ASSERT(size >= 0);
   if (FLAG_trace_zones) {
     OS::PrintErr("*** Expanding zone 0x%" Px "\n",
                  reinterpret_cast<intptr_t>(this));
     DumpZoneSizes();
   }
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(Utils::IsAligned(size, kAlignment));
   intptr_t free_size = (limit_ - position_);
   ASSERT(free_size <  size);
-#endif
 
   // First check to see if we should just chain it as a large segment.
   intptr_t max_size = Utils::RoundDown(kSegmentSize - sizeof(Segment),
                                        kAlignment);
   ASSERT(max_size > 0);
   if (size > max_size) {
     return AllocateLargeSegment(size);
   }
 
   // Allocate another segment and chain it up.
   head_ = Segment::New(kSegmentSize, head_);
 
   // Recompute 'position' and 'limit' based on the new head segment.
   uword result = Utils::RoundUp(head_->start(), kAlignment);
   position_ = result + size;
   limit_ = head_->end();
   ASSERT(position_ <= limit_);
   return result;
 }
 
 
 uword Zone::AllocateLargeSegment(intptr_t size) {
-#if defined(DEBUG)
   ASSERT(size >= 0);
   // Make sure the requested size is already properly aligned and that
   // there isn't enough room in the Zone to satisfy the request.
   ASSERT(Utils::IsAligned(size, kAlignment));
   intptr_t free_size = (limit_ - position_);
   ASSERT(free_size <  size);
-#endif
 
   // Create a new large segment and chain it up.
   ASSERT(Utils::IsAligned(sizeof(Segment), kAlignment));
   size += sizeof(Segment);  // Account for book keeping fields in size.
   large_segments_ = Segment::New(size, large_segments_);
 
   uword result = Utils::RoundUp(large_segments_->start(), kAlignment);
   return result;
 }
 
@@ skipping 14 matching lines @@
   if (a_len > 0) {
     strncpy(copy, a, a_len);
     // Insert join character.
     copy[a_len++] = join;
   }
   strncpy(&copy[a_len], b, b_len);
   return copy;
 }
 
 
-#if defined(DEBUG)
 void Zone::DumpZoneSizes() {
   intptr_t size = 0;
   for (Segment* s = large_segments_; s != NULL; s = s->next()) {
     size += s->size();
   }
   OS::PrintErr("***   Zone(0x%" Px ") size in bytes,"
                " Total = %" Pd " Large Segments = %" Pd "\n",
                reinterpret_cast<intptr_t>(this), SizeInBytes(), size);
 }
-#endif
 
 
 void Zone::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   Zone* zone = this;
   while (zone != NULL) {
     zone->handles()->VisitObjectPointers(visitor);
     zone = zone->previous_;
   }
 }
 
 
 char* Zone::PrintToString(const char* format, ...) {
   va_list args;
   va_start(args, format);
   char* buffer = OS::VSCreate(this, format, args);
   va_end(args);
   return buffer;
 }
 
 
 char* Zone::VPrint(const char* format, va_list args) {
   return OS::VSCreate(this, format, args);
 }
 
 
 }  // namespace dart