More offsets in kernel

runtime/vm/kernel_binary.cc

 // Copyright (c) 2016, 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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
 #include <vector>
 
 #include "platform/globals.h"
 #include "vm/flags.h"
@@ skipping 900 matching lines @@
     }
   }
   fields().WriteTo(writer);
   procedures().WriteTo(writer);
 }
 
 
 Class* Class::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
+  position_ = reader->ReadPosition();
   is_abstract_ = reader->ReadBool();
   name_ = Reference::ReadStringFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
 
   return this;
 }
 
 
 void Class::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
+  writer->WritePosition(position_);
   writer->WriteBool(is_abstract_);
   name_->WriteTo(writer);
   writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
 }
 
 
 NormalClass* NormalClass::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Class::ReadFrom(reader);
@@ skipping 217 matching lines @@
   writer->WriteUInt(index);
 }
 
 
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kField);
 
   position_ = reader->ReadPosition();
+  end_position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
   type_ = DartType::ReadFrom(reader);
   inferred_value_ = reader->ReadOptional<InferredValue>();
   initializer_ = reader->ReadOptional<Expression>();
   return this;
 }
 
 
 void Field::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kField);
   writer->WritePosition(position_);
+  writer->WritePosition(end_position_);
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
   writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
   type_->WriteTo(writer);
   writer->WriteOptional<InferredValue>(inferred_value_);
   writer->WriteOptional<Expression>(initializer_);
 }
 
 
 Constructor* Constructor::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kConstructor);
 
   VariableScope<ReaderHelper> parameters(reader->helper());
+  position_ = reader->ReadPosition();
+  end_position_ = reader->ReadPosition();
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = FunctionNode::ReadFrom(reader);
   initializers_.ReadFromStatic<Initializer>(reader);
   return this;
 }
 
 
 void Constructor::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kConstructor);
 
+  writer->WritePosition(position_);
+  writer->WritePosition(end_position_);
   VariableScope<WriterHelper> parameters(writer->helper());
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
   annotations_.WriteTo(writer);
   function_->WriteTo(writer);
   initializers_.WriteTo(writer);
 }
 
 
 Procedure* Procedure::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kProcedure);
 
   VariableScope<ReaderHelper> parameters(reader->helper());
+  position_ = reader->ReadPosition();
+  end_position_ = reader->ReadPosition();
   kind_ = static_cast<ProcedureKind>(reader->ReadByte());
   flags_ = reader->ReadFlags();
   name_ = Name::ReadFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   annotations_.ReadFromStatic<Expression>(reader);
   function_ = reader->ReadOptional<FunctionNode>();
   return this;
 }
 
 
 void Procedure::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kProcedure);
 
+  writer->WritePosition(position_);
+  writer->WritePosition(end_position_);
   VariableScope<WriterHelper> parameters(writer->helper());
   writer->WriteByte(kind_);
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
   writer->WriteUInt(source_uri_index_);
   annotations_.WriteTo(writer);
   writer->WriteOptional<FunctionNode>(function_);
 }
 
 
@@ skipping 204 matching lines @@
 
 void InvalidExpression::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kInvalidExpression);
 }
 
 
 VariableGet* VariableGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableGet* get = new VariableGet();
+  get->position_ = reader->ReadPosition();
   get->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
   reader->ReadOptional<DartType>();  // Unused promoted type.
   return get;
 }
 
 
 VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) {
   TRACE_READ_OFFSET();
   VariableGet* get = new VariableGet();
+  get->position_ = reader->ReadPosition();
   get->variable_ = reader->helper()->variables().Lookup(payload);
   return get;
 }
 
 
 void VariableGet::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   int index = writer->helper()->variables().Lookup(variable_);
   if ((index & kSpecializedPayloadMask) == index) {
     writer->WriteTag(kSpecializedVariableGet, static_cast<uint8_t>(index));
+    writer->WritePosition(position_);
   } else {
     writer->WriteTag(kVariableGet);
+    writer->WritePosition(position_);
     writer->WriteUInt(index);
     writer->WriteOptional<DartType>(NULL);
   }
 }
 
 
 VariableSet* VariableSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableSet* set = new VariableSet();
+  set->position_ = reader->ReadPosition();
   set->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
   set->expression_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) {
   TRACE_READ_OFFSET();
   VariableSet* set = new VariableSet();
   set->variable_ = reader->helper()->variables().Lookup(payload);
+  set->position_ = reader->ReadPosition();
   set->expression_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 void VariableSet::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   int index = writer->helper()->variables().Lookup(variable_);
   if ((index & kSpecializedPayloadMask) == index) {
     writer->WriteTag(kSpecializedVariableSet, static_cast<uint8_t>(index));
+    writer->WritePosition(position_);
   } else {
     writer->WriteTag(kVariableSet);
+    writer->WritePosition(position_);
     writer->WriteUInt(index);
   }
   expression_->WriteTo(writer);
 }
 
 
 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertyGet* get = new PropertyGet();
   get->position_ = reader->ReadPosition();
@@ skipping 275 matching lines @@
   condition_->WriteTo(writer);
   then_->WriteTo(writer);
   otherwise_->WriteTo(writer);
   writer->WriteOptional<DartType>(NULL);  // Unused static type.
 }
 
 
 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StringConcatenation* concat = new StringConcatenation();
+  concat->position_ = reader->ReadPosition();
   concat->expressions_.ReadFromStatic<Expression>(reader);
   return concat;
 }
 
 
 void StringConcatenation::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kStringConcatenation);
+  writer->WritePosition(position_);
   expressions_.WriteTo(writer);
 }
 
 
 IsExpression* IsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   IsExpression* expr = new IsExpression();
+  expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
   return expr;
 }
 
 
 void IsExpression::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kIsExpression);
+  writer->WritePosition(position_);
   operand_->WriteTo(writer);
   type_->WriteTo(writer);
 }
 
 
 AsExpression* AsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AsExpression* expr = new AsExpression();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
@@ skipping 191 matching lines @@
   writer->WriteTag(is_const_ ? kConstListLiteral : kListLiteral);
   type_->WriteTo(writer);
   expressions_.WriteTo(writer);
 }
 
 
 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   MapLiteral* literal = new MapLiteral();
   literal->is_const_ = is_const;
+  literal->position_ = reader->ReadPosition();
   literal->key_type_ = DartType::ReadFrom(reader);
   literal->value_type_ = DartType::ReadFrom(reader);
   literal->entries_.ReadFromStatic<MapEntry>(reader);
   return literal;
 }
 
 
 void MapLiteral::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(is_const_ ? kConstMapLiteral : kMapLiteral);
+  writer->WritePosition(position_);
   key_type_->WriteTo(writer);
   value_type_->WriteTo(writer);
   entries_.WriteTo(writer);
 }
 
 
 MapEntry* MapEntry::ReadFrom(Reader* reader) {
   MapEntry* entry = new MapEntry();
   entry->key_ = Expression::ReadFrom(reader);
   entry->value_ = Expression::ReadFrom(reader);
@@ skipping 381 matching lines @@
   writer->WriteTag(kIfStatement);
   condition_->WriteTo(writer);
   then_->WriteTo(writer);
   otherwise_->WriteTo(writer);
 }
 
 
 ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ReturnStatement* ret = new ReturnStatement();
+  ret->position_ = reader->ReadPosition();
   ret->expression_ = reader->ReadOptional<Expression>();
   return ret;
 }
 
 
 void ReturnStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kReturnStatement);
+  writer->WritePosition(position_);
   writer->WriteOptional<Expression>(expression_);
 }
 
 
 TryCatch* TryCatch::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TryCatch* tc = new TryCatch();
   tc->body_ = Statement::ReadFrom(reader);
   tc->catches_.ReadFromStatic<Catch>(reader);
   return tc;
@@ skipping 47 matching lines @@
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kTryFinally);
   body_->WriteTo(writer);
   finalizer_->WriteTo(writer);
 }
 
 
 YieldStatement* YieldStatement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   YieldStatement* stmt = new YieldStatement();
+  stmt->position_ = reader->ReadPosition();
   stmt->flags_ = reader->ReadByte();
   stmt->expression_ = Expression::ReadFrom(reader);
   return stmt;
 }
 
 
 void YieldStatement::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kYieldStatement);
+  writer->WritePosition(position_);
   writer->WriteByte(flags_);
   expression_->WriteTo(writer);
 }
 
 
 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   ASSERT(tag == kVariableDeclaration);
   return VariableDeclaration::ReadFromImpl(reader);
 }
 
 
 VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableDeclaration* decl = new VariableDeclaration();
+  decl->position_ = reader->ReadPosition();
   decl->flags_ = reader->ReadFlags();
   decl->name_ = Reference::ReadStringFrom(reader);
   decl->type_ = DartType::ReadFrom(reader);
   decl->inferred_value_ = reader->ReadOptional<InferredValue>();
   decl->initializer_ = reader->ReadOptional<Expression>();
   reader->helper()->variables().Push(decl);
   return decl;
 }
 
 
 void VariableDeclaration::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kVariableDeclaration);
   WriteToImpl(writer);
 }
 
 
 void VariableDeclaration::WriteToImpl(Writer* writer) {
   TRACE_WRITE_OFFSET();
+  writer->WritePosition(position_);
   writer->WriteFlags(flags_);
   name_->WriteTo(writer);
   type_->WriteTo(writer);
   writer->WriteOptional<InferredValue>(inferred_value_);
   writer->WriteOptional<Expression>(initializer_);
   writer->helper()->variables().Push(this);
 }
 
 
 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionDeclaration* decl = new FunctionDeclaration();
+  decl->position_ = reader->ReadPosition();
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
   return decl;
 }
 
 
 void FunctionDeclaration::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   writer->WriteTag(kFunctionDeclaration);
+  writer->WritePosition(position_);
   variable_->WriteToImpl(writer);
   VariableScope<WriterHelper> parameters(writer->helper());
   function_->WriteTo(writer);
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
   String* string = Reference::ReadStringFrom(reader);
   if (string->size() >= 1 && string->buffer()[0] == '_') {
     int lib_index = reader->ReadUInt();
@@ skipping 232 matching lines @@
   libraries_.WriteTo(writer);
   Reference::WriteMemberTo(writer, main_method_);
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
   FunctionNode* function = new FunctionNode();
+  function->position_ = reader->ReadPosition();
+  function->end_position_ = reader->ReadPosition();
   function->async_marker_ =
       static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
+  function->debuggable_ = reader->ReadByte() == 1 ? true : false;
   function->type_parameters().ReadFrom(reader);
   function->required_parameter_count_ = reader->ReadUInt();
   function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>(
       reader);
   function->named_parameters().ReadFromStatic<VariableDeclarationImpl>(reader);
   function->return_type_ = DartType::ReadFrom(reader);
   function->inferred_return_value_ = reader->ReadOptional<InferredValue>();
 
   LabelScope<ReaderHelper, BlockStack<LabeledStatement> > labels(
       reader->helper());
   VariableScope<ReaderHelper> vars(reader->helper());
   function->body_ = reader->ReadOptional<Statement>();
   return function;
 }
 
 
 void FunctionNode::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
   TypeParameterScope<WriterHelper> scope(writer->helper());
 
+  writer->WritePosition(position_);
+  writer->WritePosition(end_position_);
   writer->WriteByte(static_cast<uint8_t>(async_marker_));
+  writer->WriteByte(debuggable_ ? 1 : 0);
   type_parameters().WriteTo(writer);
   writer->WriteUInt(required_parameter_count());
   positional_parameters().WriteToStatic<VariableDeclarationImpl>(writer);
   named_parameters().WriteToStatic<VariableDeclarationImpl>(writer);
   return_type_->WriteTo(writer);
   writer->WriteOptional<InferredValue>(inferred_return_value_);
 
   LabelScope<WriterHelper, BlockMap<LabeledStatement> > labels(
       writer->helper());
   VariableScope<WriterHelper> vars(writer->helper());
@@ skipping 29 matching lines @@
 void WritePrecompiledKernel(ByteWriter* byte_writer, kernel::Program* program) {
   ASSERT(byte_writer != NULL);
 
   kernel::Writer writer(byte_writer);
   program->WriteTo(&writer);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)