languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-11-02 10:28:02 +00:00
Code Issues Projects Releases Packages Wiki Activity
dart-sdk/runtime/vm/kernel_binary.h
Johnni Winther a76f4d5c34 [cfe] Rename InlineClass to ExtensionTypeDeclaration 
This renames InlineClass to ExtensionTypeDeclaration, and InlineType
to ExtensionType. Members of extension type declarations are called
extension type members instead of extension type declaration members
for "brevity".

TEST=existing

Change-Id: I91ed62533ddd345644492f04dc3310d007460288
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/316780
Reviewed-by: Sigmund Cherem <sigmund@google.com>
Commit-Queue: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
Reviewed-by: Alexander Markov <alexmarkov@google.com>
2023-08-01 09:04:38 +00:00

611 lines
25 KiB
C++
Raw Blame History

// Copyright (c) 2017, 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.
#ifndef RUNTIME_VM_KERNEL_BINARY_H_
#define RUNTIME_VM_KERNEL_BINARY_H_
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "platform/unaligned.h"
#include "vm/kernel.h"
#include "vm/object.h"
namespace dart {
namespace kernel {
// Keep in sync with package:kernel/lib/binary/tag.dart,
// package:kernel/binary.md.
static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
static const uint32_t kSupportedKernelFormatVersion = 107;
// Keep in sync with package:kernel/lib/binary/tag.dart
#define KERNEL_TAG_LIST(V) \
V(Nothing, 0) \
V(Something, 1) \
V(Class, 2) \
V(Extension, 115) \
V(ExtensionTypeDeclaration, 85) \
V(FunctionNode, 3) \
V(Field, 4) \
V(Constructor, 5) \
V(Procedure, 6) \
V(InvalidInitializer, 7) \
V(FieldInitializer, 8) \
V(SuperInitializer, 9) \
V(RedirectingInitializer, 10) \
V(LocalInitializer, 11) \
V(AssertInitializer, 12) \
V(CheckLibraryIsLoaded, 13) \
V(LoadLibrary, 14) \
V(EqualsNull, 15) \
V(EqualsCall, 16) \
V(StaticTearOff, 17) \
V(ConstStaticInvocation, 18) \
V(InvalidExpression, 19) \
V(VariableGet, 20) \
V(VariableSet, 21) \
V(AbstractSuperPropertyGet, 22) \
V(AbstractSuperPropertySet, 23) \
V(SuperPropertyGet, 24) \
V(SuperPropertySet, 25) \
V(StaticGet, 26) \
V(StaticSet, 27) \
V(AbstractSuperMethodInvocation, 28) \
V(SuperMethodInvocation, 29) \
V(StaticInvocation, 30) \
V(ConstructorInvocation, 31) \
V(ConstConstructorInvocation, 32) \
V(Not, 33) \
V(NullCheck, 117) \
V(LogicalExpression, 34) \
V(ConditionalExpression, 35) \
V(StringConcatenation, 36) \
V(ListConcatenation, 111) \
V(SetConcatenation, 112) \
V(MapConcatenation, 113) \
V(InstanceCreation, 114) \
V(FileUriExpression, 116) \
V(IsExpression, 37) \
V(AsExpression, 38) \
V(StringLiteral, 39) \
V(DoubleLiteral, 40) \
V(TrueLiteral, 41) \
V(FalseLiteral, 42) \
V(NullLiteral, 43) \
V(SymbolLiteral, 44) \
V(TypeLiteral, 45) \
V(ThisExpression, 46) \
V(Rethrow, 47) \
V(Throw, 48) \
V(ListLiteral, 49) \
V(SetLiteral, 109) \
V(MapLiteral, 50) \
V(AwaitExpression, 51) \
V(FunctionExpression, 52) \
V(Let, 53) \
V(BlockExpression, 82) \
V(Instantiation, 54) \
V(PositiveIntLiteral, 55) \
V(NegativeIntLiteral, 56) \
V(BigIntLiteral, 57) \
V(ConstListLiteral, 58) \
V(ConstSetLiteral, 110) \
V(ConstMapLiteral, 59) \
V(ConstructorTearOff, 60) \
V(TypedefTearOff, 83) \
V(RedirectingFactoryTearOff, 84) \
V(RecordIndexGet, 101) \
V(RecordNameGet, 102) \
V(RecordLiteral, 104) \
V(ConstRecordLiteral, 105) \
V(ExpressionStatement, 61) \
V(Block, 62) \
V(EmptyStatement, 63) \
V(AssertStatement, 64) \
V(LabeledStatement, 65) \
V(BreakStatement, 66) \
V(WhileStatement, 67) \
V(DoStatement, 68) \
V(ForStatement, 69) \
V(ForInStatement, 70) \
V(SwitchStatement, 71) \
V(ContinueSwitchStatement, 72) \
V(IfStatement, 73) \
V(ReturnStatement, 74) \
V(TryCatch, 75) \
V(TryFinally, 76) \
V(YieldStatement, 77) \
V(VariableDeclaration, 78) \
V(FunctionDeclaration, 79) \
V(AsyncForInStatement, 80) \
V(AssertBlock, 81) \
V(TypedefType, 87) \
V(InvalidType, 90) \
V(DynamicType, 91) \
V(VoidType, 92) \
V(InterfaceType, 93) \
V(FunctionType, 94) \
V(TypeParameterType, 95) \
V(SimpleInterfaceType, 96) \
V(SimpleFunctionType, 97) \
V(NeverType, 98) \
V(IntersectionType, 99) \
V(RecordType, 100) \
V(ExtensionType, 103) \
V(ConstantExpression, 106) \
V(FutureOrType, 107) \
V(FileUriConstantExpression, 108) \
V(InstanceGet, 118) \
V(InstanceSet, 119) \
V(InstanceInvocation, 120) \
V(InstanceGetterInvocation, 89) \
V(InstanceTearOff, 121) \
V(DynamicGet, 122) \
V(DynamicSet, 123) \
V(DynamicInvocation, 124) \
V(FunctionInvocation, 125) \
V(FunctionTearOff, 126) \
V(LocalFunctionInvocation, 127) \
V(AndPattern, 128) \
V(AssignedVariablePattern, 129) \
V(CastPattern, 130) \
V(ConstantPattern, 131) \
V(InvalidPattern, 132) \
V(ListPattern, 133) \
V(MapPattern, 134) \
V(NamedPattern, 135) \
V(NullAssertPattern, 136) \
V(NullCheckPattern, 137) \
V(ObjectPattern, 138) \
V(OrPattern, 139) \
V(RecordPattern, 140) \
V(RelationalPattern, 141) \
V(RestPattern, 142) \
V(VariablePattern, 143) \
V(WildcardPattern, 144) \
V(MapPatternEntry, 145) \
V(MapPatternRestEntry, 146) \
V(PatternSwitchStatement, 147) \
V(SwitchExpression, 148) \
V(IfCaseStatement, 149) \
V(PatternAssignment, 150) \
V(PatternVariableDeclaration, 151) \
V(NullType, 152) \
V(SpecializedVariableGet, 224) \
V(SpecializedVariableSet, 232) \
V(SpecializedIntLiteral, 240)
static constexpr intptr_t kSpecializedTagHighBits = 0xe0;
static constexpr intptr_t kSpecializedTagMask = 0xf8;
static constexpr intptr_t kSpecializedPayloadMask = 0x7;
enum Tag {
#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,
kAsExpressionFlagForNonNullableByDefault = 1 << 3,
kAsExpressionFlagUnchecked = 1 << 4,
};
// Keep in sync with package:kernel/lib/ast.dart
enum IsExpressionFlags {
kIsExpressionFlagForNonNullableByDefault = 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 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_;
uint8_t 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 & ~0x80) << 8) | (buffer[offset_ + 1]);
offset_ += 2;
return value;
} else {
// 11...
ASSERT((size_ >= 4) && (offset_ >= 0) && (offset_ <= size_ - 4));
uint32_t value = ((byte0 & ~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_
Reference in a new issue View git blame Copy permalink