Add kernel_offset to all expressions; Make KernelConstMapKeyEqualsTraits use kernel_offset

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 "vm/kernel_binary.h"
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
@@ skipping 115 matching lines @@
 
 String* String::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   return Reference::ReadStringFrom(reader);
 }
 
 
 String* String::ReadFromImpl(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t bytes = reader->ReadUInt();
-  String* string = new String(reader->Consume(bytes), bytes);
-  return string;
+  return new String(reader->Consume(bytes), bytes);
 }
 
 void StringTable::ReadFrom(Reader* reader) {
   strings_.ReadFromStatic<StringImpl>(reader);
 }
 
 
 void SourceTable::ReadFrom(Reader* reader) {
   size_ = reader->helper()->program()->source_uri_table().strings().length();
   source_code_ = new String*[size_];
@@ skipping 367 matching lines @@
   InvalidExpression* invalidExpression = new InvalidExpression();
   invalidExpression->kernel_offset_ =
       reader->offset() - 1;  // -1 to include tag byte.
   return invalidExpression;
 }
 
 
 VariableGet* VariableGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableGet* get = new VariableGet();
+  get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   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->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->variable_ = reader->helper()->variables().Lookup(payload);
   return get;
 }
 
 
 VariableSet* VariableSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableSet* set = new VariableSet();
+  set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   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->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->variable_ = reader->helper()->variables().Lookup(payload);
   set->position_ = reader->ReadPosition();
   set->expression_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertyGet* get = new PropertyGet();
+  get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->name_ = Name::ReadFrom(reader);
   get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
   return get;
 }
 
 
 PropertySet* PropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   PropertySet* set = new PropertySet();
+  set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->name_ = Name::ReadFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
   return set;
 }
 
 
 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertyGet* get = new DirectPropertyGet();
+  get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->receiver_ = Expression::ReadFrom(reader);
   get->target_reference_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectPropertySet* set = new DirectPropertySet();
+  set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->receiver_ = Expression::ReadFrom(reader);
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->value_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 StaticGet* StaticGet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticGet* get = new StaticGet();
+  get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   get->position_ = reader->ReadPosition();
   get->target_reference_ = Reference::ReadMemberFrom(reader);
   return get;
 }
 
 
 StaticSet* StaticSet::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StaticSet* set = new StaticSet();
+  set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   set->position_ = reader->ReadPosition();
   set->target_reference_ = Reference::ReadMemberFrom(reader);
   set->expression_ = Expression::ReadFrom(reader);
   return set;
 }
 
 
 Arguments* Arguments::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Arguments* arguments = new Arguments();
   arguments->types().ReadFromStatic<DartType>(reader);
   arguments->positional().ReadFromStatic<Expression>(reader);
   arguments->named().ReadFromStatic<NamedExpression>(reader);
   return arguments;
 }
 
 
 NamedExpression* NamedExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   String* name = Reference::ReadStringFrom(reader);
   Expression* expression = Expression::ReadFrom(reader);
   return new NamedExpression(name, expression);
 }
 
 
 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   MethodInvocation* invocation = new MethodInvocation();
+  invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->position_ = reader->ReadPosition();
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->name_ = Name::ReadFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   invocation->interface_target_reference_ =
       Reference::ReadMemberFrom(reader, true);
   return invocation;
 }
 
 
 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DirectMethodInvocation* invocation = new DirectMethodInvocation();
+  invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->receiver_ = Expression::ReadFrom(reader);
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   StaticInvocation* invocation = new StaticInvocation();
+  invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
   invocation->procedure_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
                                                        bool is_const) {
   TRACE_READ_OFFSET();
   ConstructorInvocation* invocation = new ConstructorInvocation();
+  invocation->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   invocation->is_const_ = is_const;
   invocation->position_ = reader->ReadPosition();
   invocation->target_reference_ = Reference::ReadMemberFrom(reader);
   invocation->arguments_ = Arguments::ReadFrom(reader);
   return invocation;
 }
 
 
 Not* Not::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Not* n = new Not();
+  n->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   n->expression_ = Expression::ReadFrom(reader);
   return n;
 }
 
 
 LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   LogicalExpression* expr = new LogicalExpression();
+  expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->left_ = Expression::ReadFrom(reader);
   expr->operator_ = static_cast<Operator>(reader->ReadByte());
   expr->right_ = Expression::ReadFrom(reader);
   return expr;
 }
 
 
 ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ConditionalExpression* expr = new ConditionalExpression();
+  expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->condition_ = Expression::ReadFrom(reader);
   expr->then_ = Expression::ReadFrom(reader);
   expr->otherwise_ = Expression::ReadFrom(reader);
   reader->ReadOptional<DartType>();  // Unused static type.
   return expr;
 }
 
 
 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   StringConcatenation* concat = new StringConcatenation();
+  concat->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   concat->position_ = reader->ReadPosition();
   concat->expressions_.ReadFromStatic<Expression>(reader);
   return concat;
 }
 
 
 IsExpression* IsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   IsExpression* expr = new IsExpression();
+  expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
   return expr;
 }
 
 
 AsExpression* AsExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AsExpression* expr = new AsExpression();
+  expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   expr->position_ = reader->ReadPosition();
   expr->operand_ = Expression::ReadFrom(reader);
   expr->type_ = DartType::ReadFrom(reader);
   return expr;
 }
 
 
 StringLiteral* StringLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   intptr_t offset = reader->offset() - 1;  // -1 to include tag byte.
   StringLiteral* lit = new StringLiteral(Reference::ReadStringFrom(reader));
   lit->kernel_offset_ = offset;
   return lit;
 }
 
 
 BigintLiteral* BigintLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
-  return new BigintLiteral(Reference::ReadStringFrom(reader));
+  intptr_t offset = reader->offset() - 1;  // -1 to include tag byte.
+  BigintLiteral* lit = new BigintLiteral(Reference::ReadStringFrom(reader));
+  lit->kernel_offset_ = offset;
+  return lit;
 }
 
 
 IntLiteral* IntLiteral::ReadFrom(Reader* reader, bool is_negative) {
   TRACE_READ_OFFSET();
   IntLiteral* literal = new IntLiteral();
   literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->value_ = is_negative ? -static_cast<int64_t>(reader->ReadUInt())
                                 : reader->ReadUInt();
   return literal;
 }
 
 
 IntLiteral* IntLiteral::ReadFrom(Reader* reader, uint8_t payload) {
   TRACE_READ_OFFSET();
   IntLiteral* literal = new IntLiteral();
   literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->value_ = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
   return literal;
 }
 
 
 DoubleLiteral* DoubleLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   DoubleLiteral* literal = new DoubleLiteral();
+  literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->value_ = Reference::ReadStringFrom(reader);
   return literal;
 }
 
 
 BoolLiteral* BoolLiteral::ReadFrom(Reader* reader, bool value) {
   TRACE_READ_OFFSET();
   BoolLiteral* lit = new BoolLiteral();
   lit->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   lit->value_ = value;
   return lit;
 }
 
 
 NullLiteral* NullLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   NullLiteral* lit = new NullLiteral();
   lit->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   return lit;
 }
 
 
 SymbolLiteral* SymbolLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   SymbolLiteral* lit = new SymbolLiteral();
+  lit->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   lit->value_ = Reference::ReadStringFrom(reader);
   return lit;
 }
 
 
 TypeLiteral* TypeLiteral::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeLiteral* literal = new TypeLiteral();
+  literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->type_ = DartType::ReadFrom(reader);
   return literal;
 }
 
 
 ThisExpression* ThisExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   ThisExpression* this_expr = new ThisExpression();
   this_expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   return this_expr;
 }
 
 
 Rethrow* Rethrow::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Rethrow* rethrow = new Rethrow();
   rethrow->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   rethrow->position_ = reader->ReadPosition();
   return rethrow;
 }
 
 
 Throw* Throw::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Throw* t = new Throw();
+  t->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   t->position_ = reader->ReadPosition();
   t->expression_ = Expression::ReadFrom(reader);
   return t;
 }
 
 
 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   ListLiteral* literal = new ListLiteral();
+  literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   literal->is_const_ = is_const;
   literal->position_ = reader->ReadPosition();
   literal->type_ = DartType::ReadFrom(reader);
   literal->expressions_.ReadFromStatic<Expression>(reader);
   return literal;
 }
 
 
 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
   TRACE_READ_OFFSET();
   MapLiteral* literal = new MapLiteral();
+  literal->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   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;
 }
 
 
 MapEntry* MapEntry::ReadFrom(Reader* reader) {
   MapEntry* entry = new MapEntry();
   entry->key_ = Expression::ReadFrom(reader);
   entry->value_ = Expression::ReadFrom(reader);
   return entry;
 }
 
 
 AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   AwaitExpression* await = new AwaitExpression();
+  await->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   await->operand_ = Expression::ReadFrom(reader);
   return await;
 }
 
 
 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   VariableScope<ReaderHelper> parameters(reader->helper());
   FunctionExpression* expr = new FunctionExpression();
   expr->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
@@ skipping 343 matching lines @@
   decl->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   decl->position_ = reader->ReadPosition();
   decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   VariableScope<ReaderHelper> parameters(reader->helper());
   decl->function_ = FunctionNode::ReadFrom(reader);
   return decl;
 }
 
 
 Name* Name::ReadFrom(Reader* reader) {
-  String* string = Reference::ReadStringFrom(reader);
-  if (string->size() >= 1 && string->buffer()[0] == '_') {
+  String* name = Reference::ReadStringFrom(reader);
+  if (name->size() >= 1 && name->buffer()[0] == '_') {
     CanonicalName* library_reference = reader->ReadCanonicalNameReference();
-    return new Name(string, library_reference);
+    return new Name(name, library_reference);
   } else {
-    return new Name(string, NULL);
+    return new Name(name, NULL);
   }
 }
 
 
 DartType* DartType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
     case kInvalidType:
       return InvalidType::ReadFrom(reader);
@@ skipping 180 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)