dart::CompressedStackMaps::Iterator< PayloadHandle > Class Template Reference

#include <object.h>

Public Member Functions
	Iterator (const PayloadHandle &maps, const PayloadHandle &global_table)
	Iterator (const Iterator &it)
bool	MoveNext ()
bool	Find (uint32_t pc_offset)
uint32_t	pc_offset () const
intptr_t	Length () const
intptr_t	SpillSlotBitCount () const
bool	IsObject (intptr_t bit_index) const

Friends
class	StackMapEntry

Detailed Description

template<typename PayloadHandle>
class dart::CompressedStackMaps::Iterator< PayloadHandle >

Definition at line 6382 of file object.h.

Constructor & Destructor Documentation

Iterator() [1/2]

template<typename PayloadHandle >

dart::CompressedStackMaps::Iterator< PayloadHandle >::Iterator ( const PayloadHandle &  maps, const PayloadHandle &  global_table  )

inline

Definition at line 6384 of file object.h.

        : maps_(maps),
          bits_container_(maps.UsesGlobalTable() ? global_table : maps) {
      ASSERT(!maps_.IsNull());
      ASSERT(!bits_container_.IsNull());
      ASSERT(!maps_.IsGlobalTable());
      ASSERT(!maps_.UsesGlobalTable() || bits_container_.IsGlobalTable());
    }

Iterator() [2/2]

template<typename PayloadHandle >

dart::CompressedStackMaps::Iterator< PayloadHandle >::Iterator ( const Iterator< PayloadHandle > &  it )

inline

Definition at line 6393 of file object.h.

        : maps_(it.maps_),
          bits_container_(it.bits_container_),
          next_offset_(it.next_offset_),
          current_pc_offset_(it.current_pc_offset_),
          current_global_table_offset_(it.current_global_table_offset_),
          current_spill_slot_bit_count_(it.current_spill_slot_bit_count_),
          current_non_spill_slot_bit_count_(it.current_spill_slot_bit_count_),
          current_bits_offset_(it.current_bits_offset_) {}

Member Function Documentation

Find()

template<typename PayloadHandle >

bool dart::CompressedStackMaps::Iterator< PayloadHandle >::Find ( uint32_t  pc_offset )

inline

Definition at line 6457 of file object.h.

                                  {
      // We should never have an entry with a PC offset of 0 inside an
      // non-empty CSM, so fail.
      if (pc_offset == 0) return false;
      do {
        if (current_pc_offset_ >= pc_offset) break;
      } while (MoveNext());
      return current_pc_offset_ == pc_offset;
    }

IsObject()

template<typename PayloadHandle >

bool dart::CompressedStackMaps::Iterator< PayloadHandle >::IsObject ( intptr_t  bit_index ) const

inline

Definition at line 6488 of file object.h.

                                            {
      EnsureFullyLoadedEntry();
      ASSERT(bit_index >= 0 && bit_index < Length());
      const intptr_t byte_index = bit_index >> kBitsPerByteLog2;
      const intptr_t bit_remainder = bit_index & (kBitsPerByte - 1);
      uint8_t byte_mask = 1U << bit_remainder;
      const intptr_t byte_offset = current_bits_offset_ + byte_index;
      NoSafepointScope scope;
      return (bits_container_.data()[byte_offset] & byte_mask) != 0;
    }

Length()

template<typename PayloadHandle >

intptr_t dart::CompressedStackMaps::Iterator< PayloadHandle >::Length ( ) const

inline

Definition at line 6477 of file object.h.

                            {
      EnsureFullyLoadedEntry();
      return current_spill_slot_bit_count_ + current_non_spill_slot_bit_count_;
    }

MoveNext()

template<typename PayloadHandle >

bool dart::CompressedStackMaps::Iterator< PayloadHandle >::MoveNext ( )

inline

Definition at line 6405 of file object.h.

                    {
      if (next_offset_ >= maps_.payload_size()) {
        return false;
      }
 
      NoSafepointScope scope;
      ReadStream stream(maps_.data(), maps_.payload_size(), next_offset_);
 
      auto const pc_delta = stream.ReadLEB128();
      ASSERT(pc_delta <= (kMaxUint32 - current_pc_offset_));
      current_pc_offset_ += pc_delta;
 
      // Table-using CSMs have a table offset after the PC offset delta, whereas
      // the post-delta part of inlined entries has the same information as
      // global table entries.
      // See comments in UntaggedCompressedStackMaps for description of
      // encoding.
      if (maps_.UsesGlobalTable()) {
        current_global_table_offset_ = stream.ReadLEB128();
        ASSERT(current_global_table_offset_ < bits_container_.payload_size());
 
        // Since generally we only use entries in the GC and the GC only needs
        // the rest of the entry information if the PC offset matches, we lazily
        // load and cache the information stored in the global object when it is
        // actually requested.
        current_spill_slot_bit_count_ = -1;
        current_non_spill_slot_bit_count_ = -1;
        current_bits_offset_ = -1;
 
        next_offset_ = stream.Position();
      } else {
        current_spill_slot_bit_count_ = stream.ReadLEB128();
        ASSERT(current_spill_slot_bit_count_ >= 0);
 
        current_non_spill_slot_bit_count_ = stream.ReadLEB128();
        ASSERT(current_non_spill_slot_bit_count_ >= 0);
 
        const auto stackmap_bits =
            current_spill_slot_bit_count_ + current_non_spill_slot_bit_count_;
        const uintptr_t stackmap_size =
            Utils::RoundUp(stackmap_bits, kBitsPerByte) >> kBitsPerByteLog2;
        ASSERT(stackmap_size <= (maps_.payload_size() - stream.Position()));
 
        current_bits_offset_ = stream.Position();
        next_offset_ = current_bits_offset_ + stackmap_size;
      }
 
      return true;
    }

pc_offset()

template<typename PayloadHandle >

uint32_t dart::CompressedStackMaps::Iterator< PayloadHandle >::pc_offset ( ) const

inline

Definition at line 6471 of file object.h.

                               {
      ASSERT(HasLoadedEntry());
      return current_pc_offset_;
    }

SpillSlotBitCount()

template<typename PayloadHandle >

intptr_t dart::CompressedStackMaps::Iterator< PayloadHandle >::SpillSlotBitCount ( ) const

inline

Definition at line 6482 of file object.h.

                                       {
      EnsureFullyLoadedEntry();
      return current_spill_slot_bit_count_;
    }

Friends And Related Function Documentation

StackMapEntry

template<typename PayloadHandle >

friend class StackMapEntry

friend

Definition at line 6550 of file object.h.

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/runtime/vm/object.h