Line data    Source code

       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_ZONE_ZONE_SEGMENT_H_
       6             : #define V8_ZONE_ZONE_SEGMENT_H_
       7             : 
       8             : #include "src/v8.h"
       9             : 
      10             : // Segments represent chunks of memory: They have starting address
      11             : // (encoded in the this pointer) and a size in bytes. Segments are
      12             : // chained together forming a LIFO structure with the newest segment
      13             : // available as segment_head_. Segments are allocated using malloc()
      14             : // and de-allocated using free().
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : //  Forward declaration
      19             : class Zone;
      20             : 
      21             : class Segment {
      22             :  public:
      23    26190218 :   void Initialize(size_t size) { size_ = size; }
      24             : 
      25             :   Zone* zone() const { return zone_; }
      26    52059985 :   void set_zone(Zone* const zone) { zone_ = zone; }
      27             : 
      28             :   Segment* next() const { return next_; }
      29   105355645 :   void set_next(Segment* const next) { next_ = next; }
      30             : 
      31             :   size_t size() const { return size_; }
      32             :   size_t capacity() const { return size_ - sizeof(Segment); }
      33             : 
      34             :   Address start() const { return address(sizeof(Segment)); }
      35    52059922 :   Address end() const { return address(size_); }
      36             : 
      37             :   // Zap the contents of the segment (but not the header).
      38             :   void ZapContents();
      39             :   // Zaps the header and makes the segment unusable this way.
      40             :   void ZapHeader();
      41             : 
      42             :  private:
      43             : #ifdef DEBUG
      44             :   // Constant byte value used for zapping dead memory in debug mode.
      45             :   static const unsigned char kZapDeadByte = 0xcd;
      46             : #endif
      47             : 
      48             :   // Computes the address of the nth byte in this segment.
      49             :   Address address(size_t n) const {
      50   309758789 :     return reinterpret_cast<Address>(this) + n;
      51             :   }
      52             : 
      53             :   Zone* zone_;
      54             :   Segment* next_;
      55             :   size_t size_;
      56             : };
      57             : }  // namespace internal
      58             : }  // namespace v8
      59             : 
      60             : #endif  // V8_ZONE_ZONE_SEGMENT_H_