kernel_binary.h File Reference

#include "platform/unaligned.h"
#include "vm/kernel.h"
#include "vm/object.h"

Go to the source code of this file.

Classes
class	dart::kernel::Reader
class	dart::kernel::AlternativeReadingScope
class	dart::kernel::AlternativeReadingScopeWithNewData
class	dart::kernel::PositionScope

Namespaces
namespace	dart
namespace	dart::kernel

Macros
#define	KERNEL_TAG_LIST(V)
#define	DECLARE(Name, value)   k##Name = value,

Enumerations
enum	dart::kernel::Tag
enum	dart::kernel::ConstantTag {   dart::kernel::kNullConstant = 0 , dart::kernel::kBoolConstant = 1 , dart::kernel::kIntConstant = 2 , dart::kernel::kDoubleConstant = 3 ,   dart::kernel::kStringConstant = 4 , dart::kernel::kSymbolConstant = 5 , dart::kernel::kMapConstant = 6 , dart::kernel::kListConstant = 7 ,   dart::kernel::kSetConstant = 13 , dart::kernel::kInstanceConstant = 8 , dart::kernel::kInstantiationConstant = 9 , dart::kernel::kStaticTearOffConstant = 10 ,   dart::kernel::kTypeLiteralConstant = 11 , dart::kernel::kUnevaluatedConstant = 12 , dart::kernel::kTypedefTearOffConstant = 14 , dart::kernel::kConstructorTearOffConstant = 15 ,   dart::kernel::kRedirectingFactoryTearOffConstant = 16 , dart::kernel::kRecordConstant = 17 }
enum class	dart::kernel::KernelNullability : int8_t { dart::kernel::kUndetermined = 0 , dart::kernel::kNullable = 1 , dart::kernel::kNonNullable = 2 , dart::kernel::kLegacy = 3 }
enum	dart::kernel::Variance {   dart::kernel::kUnrelated = 0 , dart::kernel::kCovariant = 1 , dart::kernel::kContravariant = 2 , dart::kernel::kInvariant = 3 ,   dart::kernel::kLegacyCovariant = 4 }
enum	dart::kernel::AsExpressionFlags {   dart::kernel::kAsExpressionFlagTypeError = 1 << 0 , dart::kernel::kAsExpressionFlagCovarianceCheck = 1 << 1 , dart::kernel::kAsExpressionFlagForDynamic = 1 << 2 , dart::kernel::kAsExpressionFlagForLegacy = 1 << 3 ,   dart::kernel::kAsExpressionFlagUnchecked = 1 << 4 }
enum	dart::kernel::IsExpressionFlags { dart::kernel::kIsExpressionFlagForLegacy = 1 << 0 }
enum	dart::kernel::InstanceInvocationFlags { dart::kernel::kInstanceInvocationFlagInvariant = 1 << 0 , dart::kernel::kInstanceInvocationFlagBoundsSafe = 1 << 1 }
enum	dart::kernel::DynamicInvocationFlags { dart::kernel::kDynamicInvocationFlagImplicitCall = 1 << 0 }
enum	dart::kernel::ThrowFlags { dart::kernel::kThrowForErrorHandling = 1 << 0 }
enum	dart::kernel::YieldStatementFlags { dart::kernel::kYieldStatementFlagYieldStar = 1 << 0 }
enum class	dart::kernel::NamedTypeFlags : uint8_t { dart::kernel::kIsRequired = 1 << 0 }
enum class	dart::kernel::FunctionAccessKind { dart::kernel::kFunction , dart::kernel::kFunctionType , dart::kernel::kInapplicable , dart::kernel::kNullable }

Variables
static const uint32_t	dart::kernel::kMagicProgramFile = 0x90ABCDEFu
static const uint32_t	dart::kernel::kSupportedKernelFormatVersion = 117
static constexpr intptr_t	dart::kernel::kSpecializedTagHighBits = 0xe0
static constexpr intptr_t	dart::kernel::kSpecializedTagMask = 0xf8
static constexpr intptr_t	dart::kernel::kSpecializedPayloadMask = 0x7
static constexpr int	dart::kernel::SpecializedIntLiteralBias = 3
static constexpr int	dart::kernel::LibraryCountFieldCountFromEnd = 1
static constexpr int	dart::kernel::KernelFormatVersionOffset = 4
static constexpr int	dart::kernel::SourceTableFieldCountFromFirstLibraryOffset = 9
static constexpr int	dart::kernel::HeaderSize = 8

Macro Definition Documentation

DECLARE

#define DECLARE	(		Name,
			value
	)		k##Name = value,

Definition at line 185 of file kernel_binary.h.

KERNEL_TAG_LIST

#define KERNEL_TAG_LIST

(

V

)

Definition at line 24 of file kernel_binary.h.

         {
#define DECLARE(Name, value) k##Name = value,
  KERNEL_TAG_LIST(DECLARE)
#undef DECLARE
};
 
// Keep in sync with package:kernel/lib/binary/tag.dart
enum ConstantTag {
  kNullConstant = 0,
  kBoolConstant = 1,
  kIntConstant = 2,
  kDoubleConstant = 3,
  kStringConstant = 4,
  kSymbolConstant = 5,
  kMapConstant = 6,
  kListConstant = 7,
  kSetConstant = 13,
  kInstanceConstant = 8,
  kInstantiationConstant = 9,
  kStaticTearOffConstant = 10,
  kTypeLiteralConstant = 11,
  // These constants are not expected to be seen by the VM, because all
  // constants are fully evaluated.
  kUnevaluatedConstant = 12,
  kTypedefTearOffConstant = 14,
  kConstructorTearOffConstant = 15,
  kRedirectingFactoryTearOffConstant = 16,
  kRecordConstant = 17,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum class KernelNullability : int8_t {
  kUndetermined = 0,
  kNullable = 1,
  kNonNullable = 2,
  kLegacy = 3,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum Variance {
  kUnrelated = 0,
  kCovariant = 1,
  kContravariant = 2,
  kInvariant = 3,
  kLegacyCovariant = 4,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum AsExpressionFlags {
  kAsExpressionFlagTypeError = 1 << 0,
  kAsExpressionFlagCovarianceCheck = 1 << 1,
  kAsExpressionFlagForDynamic = 1 << 2,
  kAsExpressionFlagForLegacy = 1 << 3,
  kAsExpressionFlagUnchecked = 1 << 4,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum IsExpressionFlags {
  kIsExpressionFlagForLegacy = 1 << 0,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum InstanceInvocationFlags {
  kInstanceInvocationFlagInvariant = 1 << 0,
  kInstanceInvocationFlagBoundsSafe = 1 << 1,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum DynamicInvocationFlags {
  kDynamicInvocationFlagImplicitCall = 1 << 0,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum ThrowFlags {
  kThrowForErrorHandling = 1 << 0,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum YieldStatementFlags {
  kYieldStatementFlagYieldStar = 1 << 0,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum class NamedTypeFlags : uint8_t {
  kIsRequired = 1 << 0,
};
 
// Keep in sync with package:kernel/lib/ast.dart
enum class FunctionAccessKind {
  kFunction,
  kFunctionType,
  kInapplicable,
  kNullable,
};
 
static constexpr int SpecializedIntLiteralBias = 3;
static constexpr int LibraryCountFieldCountFromEnd = 1;
static constexpr int KernelFormatVersionOffset = 4;
static constexpr int SourceTableFieldCountFromFirstLibraryOffset = 9;
 
static constexpr int HeaderSize = 8;  // 'magic', 'formatVersion'.
 
class Reader : public ValueObject {
 public:
  explicit Reader(const TypedDataBase& typed_data)
      : thread_(Thread::Current()), typed_data_(&typed_data) {
    Init();
  }
 
  uint32_t ReadFromIndex(intptr_t end_offset,
                         intptr_t fields_before,
                         intptr_t list_size,
                         intptr_t list_index) {
    intptr_t org_offset = offset();
    uint32_t result =
        ReadFromIndexNoReset(end_offset, fields_before, list_size, list_index);
    offset_ = org_offset;
    return result;
  }
 
  uint32_t ReadUInt32At(intptr_t offset) const {
    ASSERT((size_ >= 4) && (offset >= 0) && (offset <= size_ - 4));
    uint32_t value =
        LoadUnaligned(reinterpret_cast<const uint32_t*>(raw_buffer_ + offset));
    return Utils::BigEndianToHost32(value);
  }
 
  uint32_t ReadFromIndexNoReset(intptr_t end_offset,
                                intptr_t fields_before,
                                intptr_t list_size,
                                intptr_t list_index) {
    offset_ = end_offset - (fields_before + list_size - list_index) * 4;
    return ReadUInt32();
  }
 
  uint32_t ReadUInt32() {
    uint32_t value = ReadUInt32At(offset_);
    offset_ += 4;
    return value;
  }
 
  double ReadDouble() {
    ASSERT((size_ >= 8) && (offset_ >= 0) && (offset_ <= size_ - 8));
    double value =
        LoadUnaligned(reinterpret_cast<const double*>(&raw_buffer_[offset_]));
    offset_ += 8;
    return value;
  }
 
  uint32_t ReadUInt() {
    ASSERT((size_ >= 1) && (offset_ >= 0) && (offset_ <= size_ - 1));
 
    const uint8_t* buffer = raw_buffer_;
    uword byte0 = buffer[offset_];
    if ((byte0 & 0x80) == 0) {
      // 0...
      offset_++;
      return byte0;
    } else if ((byte0 & 0xc0) == 0x80) {
      // 10...
      ASSERT((size_ >= 2) && (offset_ >= 0) && (offset_ <= size_ - 2));
      uint32_t value =
          ((byte0 & ~static_cast<uword>(0x80)) << 8) | (buffer[offset_ + 1]);
      offset_ += 2;
      return value;
    } else {
      // 11...
      ASSERT((size_ >= 4) && (offset_ >= 0) && (offset_ <= size_ - 4));
      uint32_t value = ((byte0 & ~static_cast<uword>(0xc0)) << 24) |
                       (buffer[offset_ + 1] << 16) |
                       (buffer[offset_ + 2] << 8) | (buffer[offset_ + 3] << 0);
      offset_ += 4;
      return value;
    }
  }
 
  intptr_t ReadSLEB128() {
    ReadStream stream(raw_buffer_, size_, offset_);
    const intptr_t result = stream.ReadSLEB128();
    offset_ = stream.Position();
    return result;
  }
 
  int64_t ReadSLEB128AsInt64() {
    ReadStream stream(raw_buffer_, size_, offset_);
    const int64_t result = stream.ReadSLEB128<int64_t>();
    offset_ = stream.Position();
    return result;
  }
 
  /**
   * Read and return a TokenPosition from this reader.
   */
  TokenPosition ReadPosition() {
    // Position is saved as unsigned,
    // but actually ranges from -1 and up (thus the -1)
    intptr_t value = ReadUInt() - 1;
    TokenPosition result = TokenPosition::Deserialize(value);
    max_position_ = TokenPosition::Max(max_position_, result);
    min_position_ = TokenPosition::Min(min_position_, result);
    return result;
  }
 
  intptr_t ReadListLength() { return ReadUInt(); }
 
  uint8_t ReadByte() { return raw_buffer_[offset_++]; }
 
  uint8_t PeekByte() { return raw_buffer_[offset_]; }
 
  void ReadBytes(uint8_t* buffer, uint8_t size) {
    for (int i = 0; i < size; i++) {
      buffer[i] = ReadByte();
    }
  }
 
  bool ReadBool() { return (ReadByte() & 1) == 1; }
 
  uint8_t ReadFlags() { return ReadByte(); }
 
  static const char* TagName(Tag tag);
 
  Tag ReadTag(uint8_t* payload = nullptr) {
    uint8_t byte = ReadByte();
    bool has_payload =
        (byte & kSpecializedTagHighBits) == kSpecializedTagHighBits;
    if (has_payload) {
      if (payload != nullptr) {
        *payload = byte & kSpecializedPayloadMask;
      }
      return static_cast<Tag>(byte & kSpecializedTagMask);
    } else {
      return static_cast<Tag>(byte);
    }
  }
 
  Tag PeekTag(uint8_t* payload = nullptr) {
    uint8_t byte = PeekByte();
    bool has_payload =
        (byte & kSpecializedTagHighBits) == kSpecializedTagHighBits;
    if (has_payload) {
      if (payload != nullptr) {
        *payload = byte & kSpecializedPayloadMask;
      }
      return static_cast<Tag>(byte & kSpecializedTagMask);
    } else {
      return static_cast<Tag>(byte);
    }
  }
 
  static Nullability ConvertNullability(KernelNullability kernel_nullability) {
    switch (kernel_nullability) {
      case KernelNullability::kNullable:
        return Nullability::kNullable;
      case KernelNullability::kLegacy:
        return Nullability::kLegacy;
      case KernelNullability::kNonNullable:
      case KernelNullability::kUndetermined:
        return Nullability::kNonNullable;
    }
    UNREACHABLE();
  }
 
  Nullability ReadNullability() {
    const uint8_t byte = ReadByte();
    return ConvertNullability(static_cast<KernelNullability>(byte));
  }
 
  Variance ReadVariance() {
    uint8_t byte = ReadByte();
    return static_cast<Variance>(byte);
  }
 
  void EnsureEnd() {
    if (offset_ != size_) {
      FATAL(
          "Reading Kernel file: Expected to be at EOF "
          "(offset: %" Pd ", size: %" Pd ")",
          offset_, size_);
    }
  }
 
  // The largest position read yet (since last reset).
  // This is automatically updated when calling ReadPosition,
  // but can be overwritten (e.g. via the PositionScope class).
  TokenPosition max_position() { return max_position_; }
  // The smallest position read yet (since last reset).
  // This is automatically updated when calling ReadPosition,
  // but can be overwritten (e.g. via the PositionScope class).
  TokenPosition min_position() { return min_position_; }
 
  // A canonical name reference of -1 indicates none (for optional names), not
  // the root name as in the canonical name table.
  NameIndex ReadCanonicalNameReference() { return NameIndex(ReadUInt() - 1); }
 
  const TypedDataBase* typed_data() { return typed_data_; }
 
  intptr_t offset() const { return offset_; }
  void set_offset(intptr_t offset) {
    ASSERT(offset < size_);
    offset_ = offset;
  }
  intptr_t size() const { return size_; }
 
  TypedDataViewPtr ViewFromTo(intptr_t start, intptr_t end) {
    return typed_data_->ViewFromTo(start, end, Heap::kOld);
  }
 
  const uint8_t* BufferAt(intptr_t offset) {
    ASSERT((offset >= 0) && (offset < size_));
    return &raw_buffer_[offset];
  }
 
  TypedDataPtr ReadLineStartsData(intptr_t line_start_count);
 
 private:
  friend class Program;
  friend class AlternativeReadingScopeWithNewData;
  friend class AlternativeReadingScope;
 
  Reader(const uint8_t* buffer, intptr_t size)
      : thread_(nullptr), raw_buffer_(buffer), size_(size) {}
 
  void Init() {
    ASSERT(typed_data_->IsExternalOrExternalView());
    raw_buffer_ = reinterpret_cast<uint8_t*>(typed_data_->DataAddr(0));
    size_ = typed_data_->LengthInBytes();
    offset_ = 0;
  }
 
  Thread* thread_ = nullptr;
 
  // A external typed data or a view on an external typed data.
  const TypedDataBase* typed_data_ = nullptr;
 
  // The raw data size/length of [typed_data_].
  const uint8_t* raw_buffer_ = nullptr;
  intptr_t size_ = 0;
 
  intptr_t offset_ = 0;
  TokenPosition max_position_ = TokenPosition::kNoSource;
  TokenPosition min_position_ = TokenPosition::kNoSource;
  intptr_t current_script_id_ = -1;
 
  friend class PositionScope;
  friend class Program;
};
 
// A helper class that saves the current reader position, goes to another reader
// position, and upon destruction, resets to the original reader position.
class AlternativeReadingScope {
 public:
  AlternativeReadingScope(Reader* reader, intptr_t new_position)
      : reader_(reader), saved_offset_(reader_->offset_) {
    reader_->offset_ = new_position;
  }
 
  explicit AlternativeReadingScope(Reader* reader)
      : reader_(reader), saved_offset_(reader_->offset_) {}
 
  ~AlternativeReadingScope() { reader_->offset_ = saved_offset_; }
 
  intptr_t saved_offset() { return saved_offset_; }
 
 private:
  Reader* const reader_;
  const intptr_t saved_offset_;
 
  DISALLOW_COPY_AND_ASSIGN(AlternativeReadingScope);
};
 
// Similar to AlternativeReadingScope, but also switches reading to another
// typed data array.
class AlternativeReadingScopeWithNewData {
 public:
  AlternativeReadingScopeWithNewData(Reader* reader,
                                     const TypedDataBase* new_typed_data,
                                     intptr_t new_position)
      : reader_(reader),
        saved_size_(reader_->size_),
        saved_raw_buffer_(reader_->raw_buffer_),
        saved_typed_data_(reader_->typed_data_),
        saved_offset_(reader_->offset_) {
    reader_->typed_data_ = new_typed_data;
    reader_->Init();
    reader_->offset_ = new_position;
  }
 
  ~AlternativeReadingScopeWithNewData() {
    reader_->raw_buffer_ = saved_raw_buffer_;
    reader_->typed_data_ = saved_typed_data_;
    reader_->size_ = saved_size_;
    reader_->offset_ = saved_offset_;
  }
 
  intptr_t saved_offset() { return saved_offset_; }
 
 private:
  Reader* reader_;
  intptr_t saved_size_;
  const uint8_t* saved_raw_buffer_;
  const TypedDataBase* saved_typed_data_;
  intptr_t saved_offset_;
 
  DISALLOW_COPY_AND_ASSIGN(AlternativeReadingScopeWithNewData);
};
 
// A helper class that resets the readers min and max positions both upon
// initialization and upon destruction, i.e. when created the min an max
// positions will be reset to "noSource", when destructing the min and max will
// be reset to have they value they would have had, if they hadn't been reset in
// the first place.
class PositionScope {
 public:
  explicit PositionScope(Reader* reader)
      : reader_(reader),
        min_(reader->min_position_),
        max_(reader->max_position_) {
    reader->min_position_ = reader->max_position_ = TokenPosition::kNoSource;
  }
 
  ~PositionScope() {
    reader_->min_position_ = TokenPosition::Min(reader_->min_position_, min_);
    reader_->max_position_ = TokenPosition::Max(reader_->max_position_, max_);
  }
 
 private:
  Reader* reader_;
  TokenPosition min_;
  TokenPosition max_;
 
  DISALLOW_COPY_AND_ASSIGN(PositionScope);
};
 
}  // namespace kernel
}  // namespace dart
 
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
#endif  // RUNTIME_VM_KERNEL_BINARY_H_