Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(453)

Side by Side Diff: runtime/vm/kernel_binary.cc

Issue 2854393002: [kernel] [partial] Streaming of kernel binary without AST nodes (Closed)
Patch Set: Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file. 3 // BSD-style license that can be found in the LICENSE file.
4 #if !defined(DART_PRECOMPILED_RUNTIME) 4 #if !defined(DART_PRECOMPILED_RUNTIME)
5 5
6 #include "vm/kernel_binary.h" 6 #include "vm/kernel_binary.h"
7 #include "platform/globals.h" 7 #include "platform/globals.h"
8 #include "vm/flags.h" 8 #include "vm/flags.h"
9 #include "vm/growable_array.h" 9 #include "vm/growable_array.h"
10 #include "vm/kernel.h" 10 #include "vm/kernel.h"
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after
187 classes().EnsureInitialized(num_classes); 187 classes().EnsureInitialized(num_classes);
188 for (intptr_t i = 0; i < num_classes; i++) { 188 for (intptr_t i = 0; i < num_classes; i++) {
189 Tag tag = reader->ReadTag(); 189 Tag tag = reader->ReadTag();
190 ASSERT(tag == kClass); 190 ASSERT(tag == kClass);
191 NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this); 191 NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
192 klass->ReadFrom(reader); 192 klass->ReadFrom(reader);
193 } 193 }
194 194
195 fields().ReadFrom<Field>(reader, this); 195 fields().ReadFrom<Field>(reader, this);
196 procedures().ReadFrom<Procedure>(reader, this); 196 procedures().ReadFrom<Procedure>(reader, this);
197
198 cannot_stream_ = classes().cannot_stream() || fields().cannot_stream() ||
199 procedures().cannot_stream();
200
197 return this; 201 return this;
198 } 202 }
199 203
200 204
201 Typedef* Typedef::ReadFrom(Reader* reader) { 205 Typedef* Typedef::ReadFrom(Reader* reader) {
202 TRACE_READ_OFFSET(); 206 TRACE_READ_OFFSET();
203 207
204 canonical_name_ = reader->ReadCanonicalNameReference(); 208 canonical_name_ = reader->ReadCanonicalNameReference();
205 position_ = reader->ReadPosition(false); 209 position_ = reader->ReadPosition(false);
206 name_index_ = reader->ReadUInt(); 210 name_index_ = reader->ReadUInt();
(...skipping 10 matching lines...) Expand all
217 221
218 canonical_name_ = reader->ReadCanonicalNameReference(); 222 canonical_name_ = reader->ReadCanonicalNameReference();
219 position_ = reader->ReadPosition(false); 223 position_ = reader->ReadPosition(false);
220 is_abstract_ = reader->ReadBool(); 224 is_abstract_ = reader->ReadBool();
221 name_index_ = reader->ReadUInt(); 225 name_index_ = reader->ReadUInt();
222 source_uri_index_ = reader->ReadUInt(); 226 source_uri_index_ = reader->ReadUInt();
223 reader->set_current_script_id(source_uri_index_); 227 reader->set_current_script_id(source_uri_index_);
224 reader->record_token_position(position_); 228 reader->record_token_position(position_);
225 annotations_.ReadFromStatic<Expression>(reader); 229 annotations_.ReadFromStatic<Expression>(reader);
226 230
231 cannot_stream_ = annotations_.cannot_stream();
232
227 return this; 233 return this;
228 } 234 }
229 235
230 236
231 NormalClass* NormalClass::ReadFrom(Reader* reader) { 237 NormalClass* NormalClass::ReadFrom(Reader* reader) {
232 TRACE_READ_OFFSET(); 238 TRACE_READ_OFFSET();
233 Class::ReadFrom(reader); 239 Class::ReadFrom(reader);
234 TypeParameterScope<ReaderHelper> scope(reader->helper()); 240 TypeParameterScope<ReaderHelper> scope(reader->helper());
235 241
236 type_parameters_.ReadFrom(reader); 242 type_parameters_.ReadFrom(reader);
237 DartType* type = reader->ReadOptional<DartType>(); 243 DartType* type = reader->ReadOptional<DartType>();
238 244
239 super_class_ = InterfaceType::Cast(type); 245 super_class_ = InterfaceType::Cast(type);
240 reader->ReadOptional<DartType>(); // Mixed-in type is unused. 246 reader->ReadOptional<DartType>(); // Mixed-in type is unused.
241 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >( 247 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
242 reader); 248 reader);
243 fields_.ReadFrom<Field>(reader, this); 249 fields_.ReadFrom<Field>(reader, this);
244 constructors_.ReadFrom<Constructor>(reader, this); 250 constructors_.ReadFrom<Constructor>(reader, this);
245 procedures_.ReadFrom<Procedure>(reader, this); 251 procedures_.ReadFrom<Procedure>(reader, this);
246 252
253 cannot_stream_ = fields_.cannot_stream() || constructors_.cannot_stream() ||
Kevin Millikin (Google) 2017/05/11 10:38:35 This is overwriting cannot_stream_ which might hav
jensj 2017/05/11 12:59:25 Done.
254 procedures_.cannot_stream();
255
247 return this; 256 return this;
248 } 257 }
249 258
250 259
251 MixinClass* MixinClass::ReadFrom(Reader* reader) { 260 MixinClass* MixinClass::ReadFrom(Reader* reader) {
252 TRACE_READ_OFFSET(); 261 TRACE_READ_OFFSET();
253 TypeParameterScope<ReaderHelper> scope(reader->helper()); 262 TypeParameterScope<ReaderHelper> scope(reader->helper());
254 263
255 Class::ReadFrom(reader); 264 Class::ReadFrom(reader);
256 type_parameters_.ReadFrom(reader); 265 type_parameters_.ReadFrom(reader);
257 first_ = InterfaceType::Cast(DartType::ReadFrom(reader)); 266 first_ = InterfaceType::Cast(DartType::ReadFrom(reader));
258 second_ = InterfaceType::Cast(DartType::ReadFrom(reader)); 267 second_ = InterfaceType::Cast(DartType::ReadFrom(reader));
259 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >( 268 implemented_classes_.ReadFromStatic<DowncastReader<DartType, InterfaceType> >(
260 reader); 269 reader);
261 constructors_.ReadFrom<Constructor>(reader, this); 270 constructors_.ReadFrom<Constructor>(reader, this);
271
272 cannot_stream_ = constructors_.cannot_stream();
273
262 return this; 274 return this;
263 } 275 }
264 276
265 277
266 CanonicalName* Reference::ReadMemberFrom(Reader* reader, bool allow_null) { 278 CanonicalName* Reference::ReadMemberFrom(Reader* reader, bool allow_null) {
267 TRACE_READ_OFFSET(); 279 TRACE_READ_OFFSET();
268 280
269 CanonicalName* canonical_name = reader->ReadCanonicalNameReference(); 281 CanonicalName* canonical_name = reader->ReadCanonicalNameReference();
270 if (canonical_name == NULL && !allow_null) { 282 if (canonical_name == NULL && !allow_null) {
271 FATAL("Expected a valid member reference, but got `null`"); 283 FATAL("Expected a valid member reference, but got `null`");
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
320 end_position_ = reader->ReadPosition(false); 332 end_position_ = reader->ReadPosition(false);
321 flags_ = reader->ReadFlags(); 333 flags_ = reader->ReadFlags();
322 name_ = Name::ReadFrom(reader); 334 name_ = Name::ReadFrom(reader);
323 source_uri_index_ = reader->ReadUInt(); 335 source_uri_index_ = reader->ReadUInt();
324 reader->set_current_script_id(source_uri_index_); 336 reader->set_current_script_id(source_uri_index_);
325 reader->record_token_position(position_); 337 reader->record_token_position(position_);
326 reader->record_token_position(end_position_); 338 reader->record_token_position(end_position_);
327 annotations_.ReadFromStatic<Expression>(reader); 339 annotations_.ReadFromStatic<Expression>(reader);
328 type_ = DartType::ReadFrom(reader); 340 type_ = DartType::ReadFrom(reader);
329 initializer_ = reader->ReadOptional<Expression>(); 341 initializer_ = reader->ReadOptional<Expression>();
342
343 cannot_stream_ = (initializer_ != NULL && initializer_->cannot_stream()) ||
344 annotations_.cannot_stream();
345
330 return this; 346 return this;
331 } 347 }
332 348
333 349
334 Constructor* Constructor::ReadFrom(Reader* reader) { 350 Constructor* Constructor::ReadFrom(Reader* reader) {
335 TRACE_READ_OFFSET(); 351 TRACE_READ_OFFSET();
336 Tag tag = reader->ReadTag(); 352 Tag tag = reader->ReadTag();
337 ASSERT(tag == kConstructor); 353 ASSERT(tag == kConstructor);
338 354
339 canonical_name_ = reader->ReadCanonicalNameReference(); 355 canonical_name_ = reader->ReadCanonicalNameReference();
340 VariableScope<ReaderHelper> parameters(reader->helper()); 356 VariableScope<ReaderHelper> parameters(reader->helper());
341 position_ = reader->ReadPosition(); 357 position_ = reader->ReadPosition();
342 end_position_ = reader->ReadPosition(); 358 end_position_ = reader->ReadPosition();
343 flags_ = reader->ReadFlags(); 359 flags_ = reader->ReadFlags();
344 name_ = Name::ReadFrom(reader); 360 name_ = Name::ReadFrom(reader);
345 annotations_.ReadFromStatic<Expression>(reader); 361 annotations_.ReadFromStatic<Expression>(reader);
346 function_ = FunctionNode::ReadFrom(reader); 362 function_ = FunctionNode::ReadFrom(reader);
347 initializers_.ReadFromStatic<Initializer>(reader); 363 initializers_.ReadFromStatic<Initializer>(reader);
364
365 cannot_stream_ = annotations_.cannot_stream() || function_->cannot_stream() ||
366 initializers_.cannot_stream();
367
348 return this; 368 return this;
349 } 369 }
350 370
351 371
352 Procedure* Procedure::ReadFrom(Reader* reader) { 372 Procedure* Procedure::ReadFrom(Reader* reader) {
353 TRACE_READ_OFFSET(); 373 TRACE_READ_OFFSET();
354 Tag tag = reader->ReadTag(); 374 Tag tag = reader->ReadTag();
355 ASSERT(tag == kProcedure); 375 ASSERT(tag == kProcedure);
356 376
357 canonical_name_ = reader->ReadCanonicalNameReference(); 377 canonical_name_ = reader->ReadCanonicalNameReference();
358 VariableScope<ReaderHelper> parameters(reader->helper()); 378 VariableScope<ReaderHelper> parameters(reader->helper());
359 position_ = reader->ReadPosition(false); 379 position_ = reader->ReadPosition(false);
360 end_position_ = reader->ReadPosition(false); 380 end_position_ = reader->ReadPosition(false);
361 kind_ = static_cast<ProcedureKind>(reader->ReadByte()); 381 kind_ = static_cast<ProcedureKind>(reader->ReadByte());
362 flags_ = reader->ReadFlags(); 382 flags_ = reader->ReadFlags();
363 name_ = Name::ReadFrom(reader); 383 name_ = Name::ReadFrom(reader);
364 source_uri_index_ = reader->ReadUInt(); 384 source_uri_index_ = reader->ReadUInt();
365 reader->set_current_script_id(source_uri_index_); 385 reader->set_current_script_id(source_uri_index_);
366 reader->record_token_position(position_); 386 reader->record_token_position(position_);
367 reader->record_token_position(end_position_); 387 reader->record_token_position(end_position_);
368 annotations_.ReadFromStatic<Expression>(reader); 388 annotations_.ReadFromStatic<Expression>(reader);
369 function_ = reader->ReadOptional<FunctionNode>(); 389 function_ = reader->ReadOptional<FunctionNode>();
390
391 cannot_stream_ = annotations_.cannot_stream() ||
392 (function_ != NULL && function_->cannot_stream());
393
370 return this; 394 return this;
371 } 395 }
372 396
373 397
374 Initializer* Initializer::ReadFrom(Reader* reader) { 398 Initializer* Initializer::ReadFrom(Reader* reader) {
375 TRACE_READ_OFFSET(); 399 TRACE_READ_OFFSET();
376 Tag tag = reader->ReadTag(); 400 Tag tag = reader->ReadTag();
377 switch (tag) { 401 switch (tag) {
378 case kInvalidInitializer: 402 case kInvalidInitializer:
379 return InvalidInitializer::ReadFromImpl(reader); 403 return InvalidInitializer::ReadFromImpl(reader);
(...skipping 16 matching lines...) Expand all
396 TRACE_READ_OFFSET(); 420 TRACE_READ_OFFSET();
397 return new InvalidInitializer(); 421 return new InvalidInitializer();
398 } 422 }
399 423
400 424
401 FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) { 425 FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) {
402 TRACE_READ_OFFSET(); 426 TRACE_READ_OFFSET();
403 FieldInitializer* initializer = new FieldInitializer(); 427 FieldInitializer* initializer = new FieldInitializer();
404 initializer->field_reference_ = Reference::ReadMemberFrom(reader); 428 initializer->field_reference_ = Reference::ReadMemberFrom(reader);
405 initializer->value_ = Expression::ReadFrom(reader); 429 initializer->value_ = Expression::ReadFrom(reader);
430
431 initializer->cannot_stream_ = initializer->value_->cannot_stream();
432
406 return initializer; 433 return initializer;
407 } 434 }
408 435
409 436
410 SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) { 437 SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) {
411 TRACE_READ_OFFSET(); 438 TRACE_READ_OFFSET();
412 SuperInitializer* init = new SuperInitializer(); 439 SuperInitializer* init = new SuperInitializer();
413 init->target_reference_ = Reference::ReadMemberFrom(reader); 440 init->target_reference_ = Reference::ReadMemberFrom(reader);
414 init->arguments_ = Arguments::ReadFrom(reader); 441 init->arguments_ = Arguments::ReadFrom(reader);
442
443 init->cannot_stream_ = init->arguments_->cannot_stream();
444
415 return init; 445 return init;
416 } 446 }
417 447
418 448
419 RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) { 449 RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) {
420 TRACE_READ_OFFSET(); 450 TRACE_READ_OFFSET();
421 RedirectingInitializer* init = new RedirectingInitializer(); 451 RedirectingInitializer* init = new RedirectingInitializer();
422 init->target_reference_ = Reference::ReadMemberFrom(reader); 452 init->target_reference_ = Reference::ReadMemberFrom(reader);
423 init->arguments_ = Arguments::ReadFrom(reader); 453 init->arguments_ = Arguments::ReadFrom(reader);
454
455 init->cannot_stream_ = init->arguments_->cannot_stream();
456
424 return init; 457 return init;
425 } 458 }
426 459
427 460
428 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) { 461 LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
429 TRACE_READ_OFFSET(); 462 TRACE_READ_OFFSET();
430 LocalInitializer* init = new LocalInitializer(); 463 LocalInitializer* init = new LocalInitializer();
431 init->variable_ = VariableDeclaration::ReadFromImpl(reader, false); 464 init->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
465
466 init->cannot_stream_ = init->variable_->cannot_stream();
467
432 return init; 468 return init;
433 } 469 }
434 470
435 471
436 Expression* Expression::ReadFrom(Reader* reader) { 472 Expression* Expression::ReadFrom(Reader* reader) {
437 TRACE_READ_OFFSET(); 473 TRACE_READ_OFFSET();
438 uint8_t payload = 0; 474 uint8_t payload = 0;
439 Tag tag = reader->ReadTag(&payload); 475 Tag tag = reader->ReadTag(&payload);
440 switch (tag) { 476 switch (tag) {
441 case kInvalidExpression: 477 case kInvalidExpression:
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after
550 reader->offset() - 1; // -1 to include tag byte. 586 reader->offset() - 1; // -1 to include tag byte.
551 return invalid_expression; 587 return invalid_expression;
552 } 588 }
553 589
554 590
555 VariableGet* VariableGet::ReadFrom(Reader* reader) { 591 VariableGet* VariableGet::ReadFrom(Reader* reader) {
556 TRACE_READ_OFFSET(); 592 TRACE_READ_OFFSET();
557 VariableGet* get = new VariableGet(); 593 VariableGet* get = new VariableGet();
558 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 594 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
559 get->position_ = reader->ReadPosition(); 595 get->position_ = reader->ReadPosition();
596 get->variable_kernel_offset_ = reader->ReadUInt();
560 get->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt()); 597 get->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
598 ASSERT(get->variable_->kernel_offset() == get->variable_kernel_offset_);
561 reader->ReadOptional<DartType>(); // Unused promoted type. 599 reader->ReadOptional<DartType>(); // Unused promoted type.
562 return get; 600 return get;
563 } 601 }
564 602
565 603
566 VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) { 604 VariableGet* VariableGet::ReadFrom(Reader* reader, uint8_t payload) {
567 TRACE_READ_OFFSET(); 605 TRACE_READ_OFFSET();
568 VariableGet* get = new VariableGet(); 606 VariableGet* get = new VariableGet();
569 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 607 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
570 get->position_ = reader->ReadPosition(); 608 get->position_ = reader->ReadPosition();
609 get->variable_kernel_offset_ = reader->ReadUInt();
571 get->variable_ = reader->helper()->variables().Lookup(payload); 610 get->variable_ = reader->helper()->variables().Lookup(payload);
611 ASSERT(get->variable_->kernel_offset() == get->variable_kernel_offset_);
572 return get; 612 return get;
573 } 613 }
574 614
575 615
576 VariableSet* VariableSet::ReadFrom(Reader* reader) { 616 VariableSet* VariableSet::ReadFrom(Reader* reader) {
577 TRACE_READ_OFFSET(); 617 TRACE_READ_OFFSET();
578 VariableSet* set = new VariableSet(); 618 VariableSet* set = new VariableSet();
579 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 619 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
580 set->position_ = reader->ReadPosition(); 620 set->position_ = reader->ReadPosition();
621 set->variable_kernel_offset_ = reader->ReadUInt();
581 set->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt()); 622 set->variable_ = reader->helper()->variables().Lookup(reader->ReadUInt());
623 ASSERT(set->variable_->kernel_offset() == set->variable_kernel_offset_);
582 set->expression_ = Expression::ReadFrom(reader); 624 set->expression_ = Expression::ReadFrom(reader);
625
626 set->cannot_stream_ = set->expression_->cannot_stream();
627
583 return set; 628 return set;
584 } 629 }
585 630
586 631
587 VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) { 632 VariableSet* VariableSet::ReadFrom(Reader* reader, uint8_t payload) {
588 TRACE_READ_OFFSET(); 633 TRACE_READ_OFFSET();
589 VariableSet* set = new VariableSet(); 634 VariableSet* set = new VariableSet();
590 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 635 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
591 set->variable_ = reader->helper()->variables().Lookup(payload); 636 set->variable_ = reader->helper()->variables().Lookup(payload);
592 set->position_ = reader->ReadPosition(); 637 set->position_ = reader->ReadPosition();
638 set->variable_kernel_offset_ = reader->ReadUInt();
639 ASSERT(set->variable_->kernel_offset() == set->variable_kernel_offset_);
593 set->expression_ = Expression::ReadFrom(reader); 640 set->expression_ = Expression::ReadFrom(reader);
641
642 set->cannot_stream_ = set->expression_->cannot_stream();
643
594 return set; 644 return set;
595 } 645 }
596 646
597 647
598 PropertyGet* PropertyGet::ReadFrom(Reader* reader) { 648 PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
599 TRACE_READ_OFFSET(); 649 TRACE_READ_OFFSET();
600 PropertyGet* get = new PropertyGet(); 650 PropertyGet* get = new PropertyGet();
601 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 651 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
602 get->position_ = reader->ReadPosition(); 652 get->position_ = reader->ReadPosition();
603 get->receiver_ = Expression::ReadFrom(reader); 653 get->receiver_ = Expression::ReadFrom(reader);
604 get->name_ = Name::ReadFrom(reader); 654 get->name_ = Name::ReadFrom(reader);
605 get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true); 655 get->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
656
657 get->cannot_stream_ = get->receiver_->cannot_stream();
658
606 return get; 659 return get;
607 } 660 }
608 661
609 662
610 PropertySet* PropertySet::ReadFrom(Reader* reader) { 663 PropertySet* PropertySet::ReadFrom(Reader* reader) {
611 TRACE_READ_OFFSET(); 664 TRACE_READ_OFFSET();
612 PropertySet* set = new PropertySet(); 665 PropertySet* set = new PropertySet();
613 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 666 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
614 set->position_ = reader->ReadPosition(); 667 set->position_ = reader->ReadPosition();
615 set->receiver_ = Expression::ReadFrom(reader); 668 set->receiver_ = Expression::ReadFrom(reader);
616 set->name_ = Name::ReadFrom(reader); 669 set->name_ = Name::ReadFrom(reader);
617 set->value_ = Expression::ReadFrom(reader); 670 set->value_ = Expression::ReadFrom(reader);
618 set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true); 671 set->interface_target_reference_ = Reference::ReadMemberFrom(reader, true);
672
673 set->cannot_stream_ =
674 set->receiver_->cannot_stream() || set->value_->cannot_stream();
675
619 return set; 676 return set;
620 } 677 }
621 678
622 679
623 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) { 680 DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
624 TRACE_READ_OFFSET(); 681 TRACE_READ_OFFSET();
625 DirectPropertyGet* get = new DirectPropertyGet(); 682 DirectPropertyGet* get = new DirectPropertyGet();
626 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 683 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
627 get->position_ = reader->ReadPosition(); 684 get->position_ = reader->ReadPosition();
628 get->receiver_ = Expression::ReadFrom(reader); 685 get->receiver_ = Expression::ReadFrom(reader);
629 get->target_reference_ = Reference::ReadMemberFrom(reader); 686 get->target_reference_ = Reference::ReadMemberFrom(reader);
687
688 get->cannot_stream_ = get->receiver_->cannot_stream();
689
630 return get; 690 return get;
631 } 691 }
632 692
633 693
634 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) { 694 DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
635 TRACE_READ_OFFSET(); 695 TRACE_READ_OFFSET();
636 DirectPropertySet* set = new DirectPropertySet(); 696 DirectPropertySet* set = new DirectPropertySet();
637 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 697 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
638 set->position_ = reader->ReadPosition(); 698 set->position_ = reader->ReadPosition();
639 set->receiver_ = Expression::ReadFrom(reader); 699 set->receiver_ = Expression::ReadFrom(reader);
640 set->target_reference_ = Reference::ReadMemberFrom(reader); 700 set->target_reference_ = Reference::ReadMemberFrom(reader);
641 set->value_ = Expression::ReadFrom(reader); 701 set->value_ = Expression::ReadFrom(reader);
702
703 set->cannot_stream_ =
704 set->receiver_->cannot_stream() || set->value_->cannot_stream();
705
642 return set; 706 return set;
643 } 707 }
644 708
645 709
646 StaticGet* StaticGet::ReadFrom(Reader* reader) { 710 StaticGet* StaticGet::ReadFrom(Reader* reader) {
647 TRACE_READ_OFFSET(); 711 TRACE_READ_OFFSET();
648 StaticGet* get = new StaticGet(); 712 StaticGet* get = new StaticGet();
649 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 713 get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
650 get->position_ = reader->ReadPosition(); 714 get->position_ = reader->ReadPosition();
651 get->target_reference_ = Reference::ReadMemberFrom(reader); 715 get->target_reference_ = Reference::ReadMemberFrom(reader);
652 return get; 716 return get;
653 } 717 }
654 718
655 719
656 StaticSet* StaticSet::ReadFrom(Reader* reader) { 720 StaticSet* StaticSet::ReadFrom(Reader* reader) {
657 TRACE_READ_OFFSET(); 721 TRACE_READ_OFFSET();
658 StaticSet* set = new StaticSet(); 722 StaticSet* set = new StaticSet();
659 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 723 set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
660 set->position_ = reader->ReadPosition(); 724 set->position_ = reader->ReadPosition();
661 set->target_reference_ = Reference::ReadMemberFrom(reader); 725 set->target_reference_ = Reference::ReadMemberFrom(reader);
662 set->expression_ = Expression::ReadFrom(reader); 726 set->expression_ = Expression::ReadFrom(reader);
727
728 set->cannot_stream_ = set->expression_->cannot_stream();
729
663 return set; 730 return set;
664 } 731 }
665 732
666 733
667 Arguments* Arguments::ReadFrom(Reader* reader) { 734 Arguments* Arguments::ReadFrom(Reader* reader) {
668 TRACE_READ_OFFSET(); 735 TRACE_READ_OFFSET();
669 Arguments* arguments = new Arguments(); 736 Arguments* arguments = new Arguments();
737 intptr_t num_arguments = reader->ReadUInt();
670 arguments->types().ReadFromStatic<DartType>(reader); 738 arguments->types().ReadFromStatic<DartType>(reader);
671 arguments->positional().ReadFromStatic<Expression>(reader); 739 arguments->positional().ReadFromStatic<Expression>(reader);
672 arguments->named().ReadFromStatic<NamedExpression>(reader); 740 arguments->named().ReadFromStatic<NamedExpression>(reader);
741 ASSERT(arguments->count() == num_arguments);
742
743 arguments->cannot_stream_ = arguments->positional().cannot_stream() ||
744 arguments->named().cannot_stream();
745
673 return arguments; 746 return arguments;
674 } 747 }
675 748
676 749
677 NamedExpression* NamedExpression::ReadFrom(Reader* reader) { 750 NamedExpression* NamedExpression::ReadFrom(Reader* reader) {
678 TRACE_READ_OFFSET(); 751 TRACE_READ_OFFSET();
679 intptr_t name_index = reader->ReadUInt(); 752 intptr_t name_index = reader->ReadUInt();
680 Expression* expression = Expression::ReadFrom(reader); 753 Expression* expression = Expression::ReadFrom(reader);
681 return new NamedExpression(name_index, expression); 754 NamedExpression* named = new NamedExpression(name_index, expression);
755
756 named->cannot_stream_ = expression->cannot_stream();
757
758 return named;
682 } 759 }
683 760
684 761
685 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) { 762 MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
686 TRACE_READ_OFFSET(); 763 TRACE_READ_OFFSET();
687 MethodInvocation* invocation = new MethodInvocation(); 764 MethodInvocation* invocation = new MethodInvocation();
688 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 765 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
689 invocation->position_ = reader->ReadPosition(); 766 invocation->position_ = reader->ReadPosition();
690 invocation->receiver_ = Expression::ReadFrom(reader); 767 invocation->receiver_ = Expression::ReadFrom(reader);
691 invocation->name_ = Name::ReadFrom(reader); 768 invocation->name_ = Name::ReadFrom(reader);
692 invocation->arguments_ = Arguments::ReadFrom(reader); 769 invocation->arguments_ = Arguments::ReadFrom(reader);
693 invocation->interface_target_reference_ = 770 invocation->interface_target_reference_ =
694 Reference::ReadMemberFrom(reader, true); 771 Reference::ReadMemberFrom(reader, true);
772
773 invocation->cannot_stream_ = invocation->receiver_->cannot_stream() ||
774 invocation->arguments_->cannot_stream();
775
695 return invocation; 776 return invocation;
696 } 777 }
697 778
698 779
699 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) { 780 DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
700 TRACE_READ_OFFSET(); 781 TRACE_READ_OFFSET();
701 DirectMethodInvocation* invocation = new DirectMethodInvocation(); 782 DirectMethodInvocation* invocation = new DirectMethodInvocation();
702 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 783 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
703 invocation->receiver_ = Expression::ReadFrom(reader); 784 invocation->receiver_ = Expression::ReadFrom(reader);
704 invocation->target_reference_ = Reference::ReadMemberFrom(reader); 785 invocation->target_reference_ = Reference::ReadMemberFrom(reader);
705 invocation->arguments_ = Arguments::ReadFrom(reader); 786 invocation->arguments_ = Arguments::ReadFrom(reader);
787
788 invocation->cannot_stream_ = invocation->receiver_->cannot_stream() ||
789 invocation->arguments_->cannot_stream();
790
706 return invocation; 791 return invocation;
707 } 792 }
708 793
709 794
710 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) { 795 StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
711 TRACE_READ_OFFSET(); 796 TRACE_READ_OFFSET();
712 StaticInvocation* invocation = new StaticInvocation(); 797 StaticInvocation* invocation = new StaticInvocation();
713 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 798 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
714 invocation->is_const_ = is_const; 799 invocation->is_const_ = is_const;
715 invocation->position_ = reader->ReadPosition(); 800 invocation->position_ = reader->ReadPosition();
716 invocation->procedure_reference_ = Reference::ReadMemberFrom(reader); 801 invocation->procedure_reference_ = Reference::ReadMemberFrom(reader);
717 invocation->arguments_ = Arguments::ReadFrom(reader); 802 invocation->arguments_ = Arguments::ReadFrom(reader);
803
804 invocation->cannot_stream_ = invocation->arguments_->cannot_stream();
805
718 return invocation; 806 return invocation;
719 } 807 }
720 808
721 809
722 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader, 810 ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
723 bool is_const) { 811 bool is_const) {
724 TRACE_READ_OFFSET(); 812 TRACE_READ_OFFSET();
725 ConstructorInvocation* invocation = new ConstructorInvocation(); 813 ConstructorInvocation* invocation = new ConstructorInvocation();
726 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 814 invocation->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
727 invocation->is_const_ = is_const; 815 invocation->is_const_ = is_const;
728 invocation->position_ = reader->ReadPosition(); 816 invocation->position_ = reader->ReadPosition();
729 invocation->target_reference_ = Reference::ReadMemberFrom(reader); 817 invocation->target_reference_ = Reference::ReadMemberFrom(reader);
730 invocation->arguments_ = Arguments::ReadFrom(reader); 818 invocation->arguments_ = Arguments::ReadFrom(reader);
819
820 invocation->cannot_stream_ = invocation->arguments_->cannot_stream();
821
731 return invocation; 822 return invocation;
732 } 823 }
733 824
734 825
735 Not* Not::ReadFrom(Reader* reader) { 826 Not* Not::ReadFrom(Reader* reader) {
736 TRACE_READ_OFFSET(); 827 TRACE_READ_OFFSET();
737 Not* n = new Not(); 828 Not* n = new Not();
738 n->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 829 n->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
739 n->expression_ = Expression::ReadFrom(reader); 830 n->expression_ = Expression::ReadFrom(reader);
831
832 n->cannot_stream_ = n->expression_->cannot_stream();
833
740 return n; 834 return n;
741 } 835 }
742 836
743 837
744 LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) { 838 LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) {
745 TRACE_READ_OFFSET(); 839 TRACE_READ_OFFSET();
746 LogicalExpression* expr = new LogicalExpression(); 840 LogicalExpression* expr = new LogicalExpression();
747 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 841 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
748 expr->left_ = Expression::ReadFrom(reader); 842 expr->left_ = Expression::ReadFrom(reader);
749 expr->operator_ = static_cast<Operator>(reader->ReadByte()); 843 expr->operator_ = static_cast<Operator>(reader->ReadByte());
750 expr->right_ = Expression::ReadFrom(reader); 844 expr->right_ = Expression::ReadFrom(reader);
845
846 expr->cannot_stream_ =
847 expr->left_->cannot_stream() || expr->right_->cannot_stream();
848
751 return expr; 849 return expr;
752 } 850 }
753 851
754 852
755 ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) { 853 ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) {
756 TRACE_READ_OFFSET(); 854 TRACE_READ_OFFSET();
757 ConditionalExpression* expr = new ConditionalExpression(); 855 ConditionalExpression* expr = new ConditionalExpression();
758 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 856 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
759 expr->condition_ = Expression::ReadFrom(reader); 857 expr->condition_ = Expression::ReadFrom(reader);
760 expr->then_ = Expression::ReadFrom(reader); 858 expr->then_ = Expression::ReadFrom(reader);
761 expr->otherwise_ = Expression::ReadFrom(reader); 859 expr->otherwise_ = Expression::ReadFrom(reader);
762 reader->ReadOptional<DartType>(); // Unused static type. 860 reader->ReadOptional<DartType>(); // Unused static type.
861
862 expr->cannot_stream_ = expr->condition_->cannot_stream() ||
863 expr->then_->cannot_stream() ||
864 expr->otherwise_->cannot_stream();
865
763 return expr; 866 return expr;
764 } 867 }
765 868
766 869
767 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) { 870 StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
768 TRACE_READ_OFFSET(); 871 TRACE_READ_OFFSET();
769 StringConcatenation* concat = new StringConcatenation(); 872 StringConcatenation* concat = new StringConcatenation();
770 concat->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 873 concat->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
771 concat->position_ = reader->ReadPosition(); 874 concat->position_ = reader->ReadPosition();
772 concat->expressions_.ReadFromStatic<Expression>(reader); 875 concat->expressions_.ReadFromStatic<Expression>(reader);
876
877 concat->cannot_stream_ = concat->expressions_.cannot_stream();
878
773 return concat; 879 return concat;
774 } 880 }
775 881
776 882
777 IsExpression* IsExpression::ReadFrom(Reader* reader) { 883 IsExpression* IsExpression::ReadFrom(Reader* reader) {
778 TRACE_READ_OFFSET(); 884 TRACE_READ_OFFSET();
779 IsExpression* expr = new IsExpression(); 885 IsExpression* expr = new IsExpression();
780 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 886 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
781 expr->position_ = reader->ReadPosition(); 887 expr->position_ = reader->ReadPosition();
782 expr->operand_ = Expression::ReadFrom(reader); 888 expr->operand_ = Expression::ReadFrom(reader);
783 expr->type_ = DartType::ReadFrom(reader); 889 expr->type_ = DartType::ReadFrom(reader);
890
891 expr->cannot_stream_ = expr->operand_->cannot_stream();
892
784 return expr; 893 return expr;
785 } 894 }
786 895
787 896
788 AsExpression* AsExpression::ReadFrom(Reader* reader) { 897 AsExpression* AsExpression::ReadFrom(Reader* reader) {
789 TRACE_READ_OFFSET(); 898 TRACE_READ_OFFSET();
790 AsExpression* expr = new AsExpression(); 899 AsExpression* expr = new AsExpression();
791 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 900 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
792 expr->position_ = reader->ReadPosition(); 901 expr->position_ = reader->ReadPosition();
793 expr->operand_ = Expression::ReadFrom(reader); 902 expr->operand_ = Expression::ReadFrom(reader);
794 expr->type_ = DartType::ReadFrom(reader); 903 expr->type_ = DartType::ReadFrom(reader);
904
905 expr->cannot_stream_ = expr->operand_->cannot_stream();
906
795 return expr; 907 return expr;
796 } 908 }
797 909
798 910
799 StringLiteral* StringLiteral::ReadFrom(Reader* reader) { 911 StringLiteral* StringLiteral::ReadFrom(Reader* reader) {
800 TRACE_READ_OFFSET(); 912 TRACE_READ_OFFSET();
801 intptr_t offset = reader->offset() - 1; // -1 to include tag byte. 913 intptr_t offset = reader->offset() - 1; // -1 to include tag byte.
802 StringLiteral* lit = new StringLiteral(reader->ReadUInt()); 914 StringLiteral* lit = new StringLiteral(reader->ReadUInt());
803 lit->kernel_offset_ = offset; 915 lit->kernel_offset_ = offset;
804 return lit; 916 return lit;
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
893 return rethrow; 1005 return rethrow;
894 } 1006 }
895 1007
896 1008
897 Throw* Throw::ReadFrom(Reader* reader) { 1009 Throw* Throw::ReadFrom(Reader* reader) {
898 TRACE_READ_OFFSET(); 1010 TRACE_READ_OFFSET();
899 Throw* t = new Throw(); 1011 Throw* t = new Throw();
900 t->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1012 t->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
901 t->position_ = reader->ReadPosition(); 1013 t->position_ = reader->ReadPosition();
902 t->expression_ = Expression::ReadFrom(reader); 1014 t->expression_ = Expression::ReadFrom(reader);
1015
1016 t->cannot_stream_ = t->expression_->cannot_stream();
1017
903 return t; 1018 return t;
904 } 1019 }
905 1020
906 1021
907 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) { 1022 ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
908 TRACE_READ_OFFSET(); 1023 TRACE_READ_OFFSET();
909 ListLiteral* literal = new ListLiteral(); 1024 ListLiteral* literal = new ListLiteral();
910 literal->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1025 literal->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
911 literal->is_const_ = is_const; 1026 literal->is_const_ = is_const;
912 literal->position_ = reader->ReadPosition(); 1027 literal->position_ = reader->ReadPosition();
913 literal->type_ = DartType::ReadFrom(reader); 1028 literal->type_ = DartType::ReadFrom(reader);
914 literal->expressions_.ReadFromStatic<Expression>(reader); 1029 literal->expressions_.ReadFromStatic<Expression>(reader);
1030
1031 literal->cannot_stream_ = literal->expressions_.cannot_stream();
1032
915 return literal; 1033 return literal;
916 } 1034 }
917 1035
918 1036
919 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) { 1037 MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
920 TRACE_READ_OFFSET(); 1038 TRACE_READ_OFFSET();
921 MapLiteral* literal = new MapLiteral(); 1039 MapLiteral* literal = new MapLiteral();
922 literal->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1040 literal->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
923 literal->is_const_ = is_const; 1041 literal->is_const_ = is_const;
924 literal->position_ = reader->ReadPosition(); 1042 literal->position_ = reader->ReadPosition();
925 literal->key_type_ = DartType::ReadFrom(reader); 1043 literal->key_type_ = DartType::ReadFrom(reader);
926 literal->value_type_ = DartType::ReadFrom(reader); 1044 literal->value_type_ = DartType::ReadFrom(reader);
927 literal->entries_.ReadFromStatic<MapEntry>(reader); 1045 literal->entries_.ReadFromStatic<MapEntry>(reader);
1046
1047 literal->cannot_stream_ = literal->entries_.cannot_stream();
1048
928 return literal; 1049 return literal;
929 } 1050 }
930 1051
931 1052
932 MapEntry* MapEntry::ReadFrom(Reader* reader) { 1053 MapEntry* MapEntry::ReadFrom(Reader* reader) {
933 MapEntry* entry = new MapEntry(); 1054 MapEntry* entry = new MapEntry();
934 entry->key_ = Expression::ReadFrom(reader); 1055 entry->key_ = Expression::ReadFrom(reader);
935 entry->value_ = Expression::ReadFrom(reader); 1056 entry->value_ = Expression::ReadFrom(reader);
1057
1058 entry->cannot_stream_ =
1059 entry->key_->cannot_stream() || entry->value_->cannot_stream();
1060
936 return entry; 1061 return entry;
937 } 1062 }
938 1063
939 1064
940 AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) { 1065 AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) {
941 TRACE_READ_OFFSET(); 1066 TRACE_READ_OFFSET();
942 AwaitExpression* await = new AwaitExpression(); 1067 AwaitExpression* await = new AwaitExpression();
943 await->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1068 await->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
944 await->operand_ = Expression::ReadFrom(reader); 1069 await->operand_ = Expression::ReadFrom(reader);
1070
1071 await->cannot_stream_ = await->operand_->cannot_stream();
1072
945 return await; 1073 return await;
946 } 1074 }
947 1075
948 1076
949 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) { 1077 FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
950 TRACE_READ_OFFSET(); 1078 TRACE_READ_OFFSET();
951 VariableScope<ReaderHelper> parameters(reader->helper()); 1079 VariableScope<ReaderHelper> parameters(reader->helper());
952 FunctionExpression* expr = new FunctionExpression(); 1080 FunctionExpression* expr = new FunctionExpression();
953 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1081 expr->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
954 expr->function_ = FunctionNode::ReadFrom(reader); 1082 expr->function_ = FunctionNode::ReadFrom(reader);
1083
1084 expr->cannot_stream_ = true;
1085
955 return expr; 1086 return expr;
956 } 1087 }
957 1088
958 1089
959 Let* Let::ReadFrom(Reader* reader) { 1090 Let* Let::ReadFrom(Reader* reader) {
960 TRACE_READ_OFFSET(); 1091 TRACE_READ_OFFSET();
961 VariableScope<ReaderHelper> vars(reader->helper()); 1092 VariableScope<ReaderHelper> vars(reader->helper());
962 PositionScope scope(reader); 1093 PositionScope scope(reader);
963 1094
964 Let* let = new Let(); 1095 Let* let = new Let();
965 let->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1096 let->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
966 let->variable_ = VariableDeclaration::ReadFromImpl(reader, false); 1097 let->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
967 let->body_ = Expression::ReadFrom(reader); 1098 let->body_ = Expression::ReadFrom(reader);
968 let->position_ = reader->min_position(); 1099 let->position_ = reader->min_position();
969 let->end_position_ = reader->max_position(); 1100 let->end_position_ = reader->max_position();
970 1101
1102 let->cannot_stream_ =
1103 let->variable_->cannot_stream() || let->body_->cannot_stream();
1104
971 return let; 1105 return let;
972 } 1106 }
973 1107
974 1108
975 VectorCreation* VectorCreation::ReadFrom(Reader* reader) { 1109 VectorCreation* VectorCreation::ReadFrom(Reader* reader) {
976 TRACE_READ_OFFSET(); 1110 TRACE_READ_OFFSET();
977 1111
978 VectorCreation* vector_creation = new VectorCreation(); 1112 VectorCreation* vector_creation = new VectorCreation();
979 vector_creation->kernel_offset_ = 1113 vector_creation->kernel_offset_ =
980 reader->offset() - 1; // -1 to include tag byte. 1114 reader->offset() - 1; // -1 to include tag byte.
981 vector_creation->value_ = reader->ReadUInt(); 1115 vector_creation->value_ = reader->ReadUInt();
982 1116
983 return vector_creation; 1117 return vector_creation;
984 } 1118 }
985 1119
986 1120
987 VectorGet* VectorGet::ReadFrom(Reader* reader) { 1121 VectorGet* VectorGet::ReadFrom(Reader* reader) {
988 TRACE_READ_OFFSET(); 1122 TRACE_READ_OFFSET();
989 1123
990 VectorGet* vector_get = new VectorGet(); 1124 VectorGet* vector_get = new VectorGet();
991 vector_get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1125 vector_get->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
992 vector_get->vector_expression_ = Expression::ReadFrom(reader); 1126 vector_get->vector_expression_ = Expression::ReadFrom(reader);
993 vector_get->index_ = reader->ReadUInt(); 1127 vector_get->index_ = reader->ReadUInt();
994 1128
1129 vector_get->cannot_stream_ = vector_get->vector_expression_->cannot_stream();
1130
995 return vector_get; 1131 return vector_get;
996 } 1132 }
997 1133
998 1134
999 VectorSet* VectorSet::ReadFrom(Reader* reader) { 1135 VectorSet* VectorSet::ReadFrom(Reader* reader) {
1000 TRACE_READ_OFFSET(); 1136 TRACE_READ_OFFSET();
1001 1137
1002 VectorSet* vector_set = new VectorSet(); 1138 VectorSet* vector_set = new VectorSet();
1003 vector_set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1139 vector_set->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1004 vector_set->vector_expression_ = Expression::ReadFrom(reader); 1140 vector_set->vector_expression_ = Expression::ReadFrom(reader);
1005 vector_set->index_ = reader->ReadUInt(); 1141 vector_set->index_ = reader->ReadUInt();
1006 vector_set->value_ = Expression::ReadFrom(reader); 1142 vector_set->value_ = Expression::ReadFrom(reader);
1007 1143
1144 vector_set->cannot_stream_ =
1145 vector_set->vector_expression_->cannot_stream() ||
1146 vector_set->value_->cannot_stream();
1147
1008 return vector_set; 1148 return vector_set;
1009 } 1149 }
1010 1150
1011 1151
1012 VectorCopy* VectorCopy::ReadFrom(Reader* reader) { 1152 VectorCopy* VectorCopy::ReadFrom(Reader* reader) {
1013 TRACE_READ_OFFSET(); 1153 TRACE_READ_OFFSET();
1014 1154
1015 VectorCopy* vector_copy = new VectorCopy(); 1155 VectorCopy* vector_copy = new VectorCopy();
1016 vector_copy->kernel_offset_ = 1156 vector_copy->kernel_offset_ =
1017 reader->offset() - 1; // -1 to include tag byte. 1157 reader->offset() - 1; // -1 to include tag byte.
1018 vector_copy->vector_expression_ = Expression::ReadFrom(reader); 1158 vector_copy->vector_expression_ = Expression::ReadFrom(reader);
1019 1159
1160 vector_copy->cannot_stream_ =
1161 vector_copy->vector_expression_->cannot_stream();
1162
1020 return vector_copy; 1163 return vector_copy;
1021 } 1164 }
1022 1165
1023 1166
1024 ClosureCreation* ClosureCreation::ReadFrom(Reader* reader) { 1167 ClosureCreation* ClosureCreation::ReadFrom(Reader* reader) {
1025 TRACE_READ_OFFSET(); 1168 TRACE_READ_OFFSET();
1026 1169
1027 ClosureCreation* closure_creation = new ClosureCreation(); 1170 ClosureCreation* closure_creation = new ClosureCreation();
1028 closure_creation->kernel_offset_ = 1171 closure_creation->kernel_offset_ =
1029 reader->offset() - 1; // to include tag byte. 1172 reader->offset() - 1; // to include tag byte.
1030 closure_creation->top_level_function_reference_ = 1173 closure_creation->top_level_function_reference_ =
1031 Reference::ReadMemberFrom(reader); 1174 Reference::ReadMemberFrom(reader);
1032 closure_creation->context_vector_ = Expression::ReadFrom(reader); 1175 closure_creation->context_vector_ = Expression::ReadFrom(reader);
1033 closure_creation->function_type_ = 1176 closure_creation->function_type_ =
1034 FunctionType::Cast(DartType::ReadFrom(reader)); 1177 FunctionType::Cast(DartType::ReadFrom(reader));
1035 1178
1179 closure_creation->cannot_stream_ =
1180 closure_creation->context_vector_->cannot_stream();
1181
1036 return closure_creation; 1182 return closure_creation;
1037 } 1183 }
1038 1184
1039 1185
1040 Statement* Statement::ReadFrom(Reader* reader) { 1186 Statement* Statement::ReadFrom(Reader* reader) {
1041 TRACE_READ_OFFSET(); 1187 TRACE_READ_OFFSET();
1042 Tag tag = reader->ReadTag(); 1188 Tag tag = reader->ReadTag();
1043 switch (tag) { 1189 switch (tag) {
1044 case kInvalidStatement: 1190 case kInvalidStatement:
1045 return InvalidStatement::ReadFrom(reader); 1191 return InvalidStatement::ReadFrom(reader);
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
1085 return FunctionDeclaration::ReadFrom(reader); 1231 return FunctionDeclaration::ReadFrom(reader);
1086 default: 1232 default:
1087 UNREACHABLE(); 1233 UNREACHABLE();
1088 } 1234 }
1089 return NULL; 1235 return NULL;
1090 } 1236 }
1091 1237
1092 1238
1093 InvalidStatement* InvalidStatement::ReadFrom(Reader* reader) { 1239 InvalidStatement* InvalidStatement::ReadFrom(Reader* reader) {
1094 TRACE_READ_OFFSET(); 1240 TRACE_READ_OFFSET();
1095 return new InvalidStatement(); 1241 InvalidStatement* stmt = new InvalidStatement();
1242 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1243 return stmt;
1096 } 1244 }
1097 1245
1098 1246
1099 ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) { 1247 ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) {
1100 TRACE_READ_OFFSET(); 1248 TRACE_READ_OFFSET();
1101 return new ExpressionStatement(Expression::ReadFrom(reader)); 1249 intptr_t offset = reader->offset() - 1; // -1 to include tag byte.
1250 ExpressionStatement* stmt =
1251 new ExpressionStatement(Expression::ReadFrom(reader));
1252 stmt->kernel_offset_ = offset;
1253
1254 stmt->cannot_stream_ = stmt->expression_->cannot_stream();
1255
1256 return stmt;
1102 } 1257 }
1103 1258
1104 1259
1105 Block* Block::ReadFromImpl(Reader* reader) { 1260 Block* Block::ReadFromImpl(Reader* reader) {
1106 TRACE_READ_OFFSET(); 1261 TRACE_READ_OFFSET();
1107 PositionScope scope(reader); 1262 PositionScope scope(reader);
1108 1263
1109 VariableScope<ReaderHelper> vars(reader->helper()); 1264 VariableScope<ReaderHelper> vars(reader->helper());
1110 Block* block = new Block(); 1265 Block* block = new Block();
1111 block->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1266 block->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1112 block->statements().ReadFromStatic<Statement>(reader); 1267 block->statements().ReadFromStatic<Statement>(reader);
1113 block->position_ = reader->min_position(); 1268 block->position_ = reader->min_position();
1114 block->end_position_ = reader->max_position(); 1269 block->end_position_ = reader->max_position();
1115 1270
1271 block->cannot_stream_ = block->statements().cannot_stream();
1272
1116 return block; 1273 return block;
1117 } 1274 }
1118 1275
1119 1276
1120 EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) { 1277 EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) {
1121 TRACE_READ_OFFSET(); 1278 TRACE_READ_OFFSET();
1122 return new EmptyStatement(); 1279 EmptyStatement* stmt = new EmptyStatement();
1280 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1281 return stmt;
1123 } 1282 }
1124 1283
1125 1284
1126 AssertStatement* AssertStatement::ReadFrom(Reader* reader) { 1285 AssertStatement* AssertStatement::ReadFrom(Reader* reader) {
1127 TRACE_READ_OFFSET(); 1286 TRACE_READ_OFFSET();
1128 AssertStatement* stmt = new AssertStatement(); 1287 AssertStatement* stmt = new AssertStatement();
1288 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1129 stmt->condition_ = Expression::ReadFrom(reader); 1289 stmt->condition_ = Expression::ReadFrom(reader);
1130 stmt->message_ = reader->ReadOptional<Expression>(); 1290 stmt->message_ = reader->ReadOptional<Expression>();
1291
1292 stmt->cannot_stream_ =
1293 stmt->condition_->cannot_stream() ||
1294 (stmt->message_ != NULL && stmt->message_->cannot_stream());
1295
1131 return stmt; 1296 return stmt;
1132 } 1297 }
1133 1298
1134 1299
1135 LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) { 1300 LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) {
1136 TRACE_READ_OFFSET(); 1301 TRACE_READ_OFFSET();
1137 LabeledStatement* stmt = new LabeledStatement(); 1302 LabeledStatement* stmt = new LabeledStatement();
1303 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1304
1138 reader->helper()->labels()->Push(stmt); 1305 reader->helper()->labels()->Push(stmt);
1139 stmt->body_ = Statement::ReadFrom(reader); 1306 stmt->body_ = Statement::ReadFrom(reader);
1140 reader->helper()->labels()->Pop(stmt); 1307 reader->helper()->labels()->Pop(stmt);
1308
1309 stmt->cannot_stream_ = stmt->body_->cannot_stream();
1310
1141 return stmt; 1311 return stmt;
1142 } 1312 }
1143 1313
1144 1314
1145 BreakStatement* BreakStatement::ReadFrom(Reader* reader) { 1315 BreakStatement* BreakStatement::ReadFrom(Reader* reader) {
1146 TRACE_READ_OFFSET(); 1316 TRACE_READ_OFFSET();
1147 BreakStatement* stmt = new BreakStatement(); 1317 BreakStatement* stmt = new BreakStatement();
1318 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1148 stmt->position_ = reader->ReadPosition(); 1319 stmt->position_ = reader->ReadPosition();
1149 stmt->target_ = reader->helper()->labels()->Lookup(reader->ReadUInt()); 1320 stmt->target_index_ = reader->ReadUInt();
1150 return stmt; 1321 return stmt;
1151 } 1322 }
1152 1323
1153 1324
1154 WhileStatement* WhileStatement::ReadFrom(Reader* reader) { 1325 WhileStatement* WhileStatement::ReadFrom(Reader* reader) {
1155 TRACE_READ_OFFSET(); 1326 TRACE_READ_OFFSET();
1156 WhileStatement* stmt = new WhileStatement(); 1327 WhileStatement* stmt = new WhileStatement();
1328 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1157 stmt->condition_ = Expression::ReadFrom(reader); 1329 stmt->condition_ = Expression::ReadFrom(reader);
1158 stmt->body_ = Statement::ReadFrom(reader); 1330 stmt->body_ = Statement::ReadFrom(reader);
1331
1332 stmt->cannot_stream_ =
1333 stmt->condition_->cannot_stream() || stmt->body_->cannot_stream();
1334
1159 return stmt; 1335 return stmt;
1160 } 1336 }
1161 1337
1162 1338
1163 DoStatement* DoStatement::ReadFrom(Reader* reader) { 1339 DoStatement* DoStatement::ReadFrom(Reader* reader) {
1164 TRACE_READ_OFFSET(); 1340 TRACE_READ_OFFSET();
1165 DoStatement* dostmt = new DoStatement(); 1341 DoStatement* dostmt = new DoStatement();
1342 dostmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1166 dostmt->body_ = Statement::ReadFrom(reader); 1343 dostmt->body_ = Statement::ReadFrom(reader);
1167 dostmt->condition_ = Expression::ReadFrom(reader); 1344 dostmt->condition_ = Expression::ReadFrom(reader);
1345
1346 dostmt->cannot_stream_ =
1347 dostmt->body_->cannot_stream() || dostmt->condition_->cannot_stream();
1348
1168 return dostmt; 1349 return dostmt;
1169 } 1350 }
1170 1351
1171 1352
1172 ForStatement* ForStatement::ReadFrom(Reader* reader) { 1353 ForStatement* ForStatement::ReadFrom(Reader* reader) {
1173 TRACE_READ_OFFSET(); 1354 TRACE_READ_OFFSET();
1174 VariableScope<ReaderHelper> vars(reader->helper()); 1355 VariableScope<ReaderHelper> vars(reader->helper());
1175 PositionScope scope(reader); 1356 PositionScope scope(reader);
1176 1357
1177 ForStatement* forstmt = new ForStatement(); 1358 ForStatement* forstmt = new ForStatement();
1178 forstmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1359 forstmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1179 forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader); 1360 forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader);
1180 forstmt->condition_ = reader->ReadOptional<Expression>(); 1361 forstmt->condition_ = reader->ReadOptional<Expression>();
1181 forstmt->updates_.ReadFromStatic<Expression>(reader); 1362 forstmt->updates_.ReadFromStatic<Expression>(reader);
1182 forstmt->body_ = Statement::ReadFrom(reader); 1363 forstmt->body_ = Statement::ReadFrom(reader);
1183 forstmt->end_position_ = reader->max_position(); 1364 forstmt->end_position_ = reader->max_position();
1184 forstmt->position_ = reader->min_position(); 1365 forstmt->position_ = reader->min_position();
1185 1366
1367 forstmt->cannot_stream_ =
1368 forstmt->body_->cannot_stream() ||
1369 (forstmt->condition_ != NULL && forstmt->condition_->cannot_stream()) ||
1370 forstmt->variables_.cannot_stream() || forstmt->updates_.cannot_stream();
1371
1186 return forstmt; 1372 return forstmt;
1187 } 1373 }
1188 1374
1189 1375
1190 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) { 1376 ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
1191 TRACE_READ_OFFSET(); 1377 TRACE_READ_OFFSET();
1192 VariableScope<ReaderHelper> vars(reader->helper()); 1378 VariableScope<ReaderHelper> vars(reader->helper());
1193 PositionScope scope(reader); 1379 PositionScope scope(reader);
1194 1380
1195 ForInStatement* forinstmt = new ForInStatement(); 1381 ForInStatement* forinstmt = new ForInStatement();
1196 forinstmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1382 forinstmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1197 forinstmt->is_async_ = is_async; 1383 forinstmt->is_async_ = is_async;
1198 forinstmt->position_ = reader->ReadPosition(); 1384 forinstmt->position_ = reader->ReadPosition();
1199 forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader, false); 1385 forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
1200 forinstmt->iterable_ = Expression::ReadFrom(reader); 1386 forinstmt->iterable_ = Expression::ReadFrom(reader);
1201 forinstmt->body_ = Statement::ReadFrom(reader); 1387 forinstmt->body_ = Statement::ReadFrom(reader);
1202 forinstmt->end_position_ = reader->max_position(); 1388 forinstmt->end_position_ = reader->max_position();
1203 if (!forinstmt->position_.IsReal()) { 1389 if (!forinstmt->position_.IsReal()) {
1204 forinstmt->position_ = reader->min_position(); 1390 forinstmt->position_ = reader->min_position();
1205 } 1391 }
1206 forinstmt->variable_->set_end_position(forinstmt->position_); 1392 forinstmt->variable_->set_end_position(forinstmt->position_);
1207 1393
1394 forinstmt->cannot_stream_ = forinstmt->variable_->cannot_stream() ||
1395 forinstmt->iterable_->cannot_stream() ||
1396 forinstmt->body_->cannot_stream();
1397
1208 return forinstmt; 1398 return forinstmt;
1209 } 1399 }
1210 1400
1211 1401
1212 SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) { 1402 SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) {
1213 TRACE_READ_OFFSET(); 1403 TRACE_READ_OFFSET();
1214 SwitchCaseScope<ReaderHelper> scope(reader->helper());
1215 SwitchStatement* stmt = new SwitchStatement(); 1404 SwitchStatement* stmt = new SwitchStatement();
1405 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1216 stmt->condition_ = Expression::ReadFrom(reader); 1406 stmt->condition_ = Expression::ReadFrom(reader);
1217 // We need to explicitly create empty [SwitchCase]s first in order to add them
1218 // to the [SwitchCaseScope]. This is necessary since a [Statement] in a switch
1219 // case can refer to one defined later on.
1220 int count = reader->ReadUInt(); 1407 int count = reader->ReadUInt();
1408 stmt->cases_.EnsureInitialized(count);
1221 for (intptr_t i = 0; i < count; i++) { 1409 for (intptr_t i = 0; i < count; i++) {
1222 SwitchCase* sc = stmt->cases_.GetOrCreate<SwitchCase>(i); 1410 SwitchCase* sc = stmt->cases_.GetOrCreate<SwitchCase>(i);
1223 reader->helper()->switch_cases().Push(sc);
1224 }
1225 for (intptr_t i = 0; i < count; i++) {
1226 SwitchCase* sc = stmt->cases_[i];
1227 sc->ReadFrom(reader); 1411 sc->ReadFrom(reader);
1228 } 1412 }
1413
1414 stmt->cannot_stream_ =
1415 stmt->condition_->cannot_stream() || stmt->cases_.cannot_stream();
1416
1229 return stmt; 1417 return stmt;
1230 } 1418 }
1231 1419
1232 1420
1233 SwitchCase* SwitchCase::ReadFrom(Reader* reader) { 1421 SwitchCase* SwitchCase::ReadFrom(Reader* reader) {
1234 TRACE_READ_OFFSET(); 1422 TRACE_READ_OFFSET();
1235 expressions_.ReadFromStatic<Expression>(reader); 1423 int length = reader->ReadListLength();
1236 for (intptr_t i = 0; i < expressions_.length(); ++i) { 1424 expressions_.EnsureInitialized(length);
1237 expressions_[i]->set_position(reader->ReadPosition()); 1425
1426 for (intptr_t i = 0; i < length; i++) {
1427 ASSERT(expressions_[i] == NULL);
1428 TokenPosition position = reader->ReadPosition();
1429 expressions_[i] = Expression::ReadFrom(reader);
1430 expressions_[i]->set_position(position);
1238 } 1431 }
1239 is_default_ = reader->ReadBool(); 1432 is_default_ = reader->ReadBool();
1240 body_ = Statement::ReadFrom(reader); 1433 body_ = Statement::ReadFrom(reader);
1434
1435 cannot_stream_ = expressions_.cannot_stream() || body_->cannot_stream();
1436
1241 return this; 1437 return this;
1242 } 1438 }
1243 1439
1244 1440
1245 ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) { 1441 ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) {
1246 TRACE_READ_OFFSET(); 1442 TRACE_READ_OFFSET();
1247 ContinueSwitchStatement* stmt = new ContinueSwitchStatement(); 1443 ContinueSwitchStatement* stmt = new ContinueSwitchStatement();
1248 stmt->target_ = reader->helper()->switch_cases().Lookup(reader->ReadUInt()); 1444 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1445 stmt->target_index_ = reader->ReadUInt();
1446
1249 return stmt; 1447 return stmt;
1250 } 1448 }
1251 1449
1252 1450
1253 IfStatement* IfStatement::ReadFrom(Reader* reader) { 1451 IfStatement* IfStatement::ReadFrom(Reader* reader) {
1254 TRACE_READ_OFFSET(); 1452 TRACE_READ_OFFSET();
1255 IfStatement* ifstmt = new IfStatement(); 1453 IfStatement* ifstmt = new IfStatement();
1454 ifstmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1256 ifstmt->condition_ = Expression::ReadFrom(reader); 1455 ifstmt->condition_ = Expression::ReadFrom(reader);
1257 ifstmt->then_ = Statement::ReadFrom(reader); 1456 ifstmt->then_ = Statement::ReadFrom(reader);
1258 ifstmt->otherwise_ = Statement::ReadFrom(reader); 1457 ifstmt->otherwise_ = Statement::ReadFrom(reader);
1458
1459 ifstmt->cannot_stream_ = ifstmt->condition_->cannot_stream() ||
1460 ifstmt->then_->cannot_stream() ||
1461 ifstmt->otherwise_->cannot_stream();
1462
1259 return ifstmt; 1463 return ifstmt;
1260 } 1464 }
1261 1465
1262 1466
1263 ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) { 1467 ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) {
1264 TRACE_READ_OFFSET(); 1468 TRACE_READ_OFFSET();
1265 ReturnStatement* ret = new ReturnStatement(); 1469 ReturnStatement* ret = new ReturnStatement();
1470 ret->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1266 ret->position_ = reader->ReadPosition(); 1471 ret->position_ = reader->ReadPosition();
1267 ret->expression_ = reader->ReadOptional<Expression>(); 1472 ret->expression_ = reader->ReadOptional<Expression>();
1473
1474 ret->cannot_stream_ =
1475 (ret->expression_ != NULL && ret->expression_->cannot_stream());
1476
1268 return ret; 1477 return ret;
1269 } 1478 }
1270 1479
1271 1480
1272 TryCatch* TryCatch::ReadFrom(Reader* reader) { 1481 TryCatch* TryCatch::ReadFrom(Reader* reader) {
1273 TRACE_READ_OFFSET(); 1482 TRACE_READ_OFFSET();
1274 PositionScope scope(reader); 1483 PositionScope scope(reader);
1275 1484
1276 TryCatch* tc = new TryCatch(); 1485 TryCatch* tc = new TryCatch();
1486 tc->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1277 tc->body_ = Statement::ReadFrom(reader); 1487 tc->body_ = Statement::ReadFrom(reader);
1488 reader->ReadBool(); // whether any catch needs a stacktrace.
1278 tc->catches_.ReadFromStatic<Catch>(reader); 1489 tc->catches_.ReadFromStatic<Catch>(reader);
1279 tc->position_ = reader->min_position(); 1490 tc->position_ = reader->min_position();
1280 1491
1492 tc->cannot_stream_ =
1493 tc->body_->cannot_stream() || tc->catches_.cannot_stream();
1494
1281 return tc; 1495 return tc;
1282 } 1496 }
1283 1497
1284 1498
1285 Catch* Catch::ReadFrom(Reader* reader) { 1499 Catch* Catch::ReadFrom(Reader* reader) {
1286 TRACE_READ_OFFSET(); 1500 TRACE_READ_OFFSET();
1287 VariableScope<ReaderHelper> vars(reader->helper()); 1501 VariableScope<ReaderHelper> vars(reader->helper());
1288 PositionScope scope(reader); 1502 PositionScope scope(reader);
1289 1503
1290 Catch* c = new Catch(); 1504 Catch* c = new Catch();
1291 c->kernel_offset_ = reader->offset(); // Catch has no tag. 1505 c->kernel_offset_ = reader->offset(); // Catch has no tag.
1292 c->guard_ = DartType::ReadFrom(reader); 1506 c->guard_ = DartType::ReadFrom(reader);
1293 c->exception_ = 1507 c->exception_ =
1294 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>(); 1508 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
1295 c->stack_trace_ = 1509 c->stack_trace_ =
1296 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>(); 1510 reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
1297 c->body_ = Statement::ReadFrom(reader); 1511 c->body_ = Statement::ReadFrom(reader);
1298 c->end_position_ = reader->max_position(); 1512 c->end_position_ = reader->max_position();
1299 c->position_ = reader->min_position(); 1513 c->position_ = reader->min_position();
1300 1514
1515 c->cannot_stream_ = c->body_->cannot_stream();
1516
1301 return c; 1517 return c;
1302 } 1518 }
1303 1519
1304 1520
1305 TryFinally* TryFinally::ReadFrom(Reader* reader) { 1521 TryFinally* TryFinally::ReadFrom(Reader* reader) {
1306 TRACE_READ_OFFSET(); 1522 TRACE_READ_OFFSET();
1307 TryFinally* tf = new TryFinally(); 1523 TryFinally* tf = new TryFinally();
1524 tf->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1308 tf->body_ = Statement::ReadFrom(reader); 1525 tf->body_ = Statement::ReadFrom(reader);
1309 tf->finalizer_ = Statement::ReadFrom(reader); 1526 tf->finalizer_ = Statement::ReadFrom(reader);
1527
1528 tf->cannot_stream_ =
1529 tf->body_->cannot_stream() || tf->finalizer_->cannot_stream();
1530
1310 return tf; 1531 return tf;
1311 } 1532 }
1312 1533
1313 1534
1314 YieldStatement* YieldStatement::ReadFrom(Reader* reader) { 1535 YieldStatement* YieldStatement::ReadFrom(Reader* reader) {
1315 TRACE_READ_OFFSET(); 1536 TRACE_READ_OFFSET();
1316 YieldStatement* stmt = new YieldStatement(); 1537 YieldStatement* stmt = new YieldStatement();
1538 stmt->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1317 stmt->position_ = reader->ReadPosition(); 1539 stmt->position_ = reader->ReadPosition();
1318 reader->record_yield_token_position(stmt->position_); 1540 reader->record_yield_token_position(stmt->position_);
1319 stmt->flags_ = reader->ReadByte(); 1541 stmt->flags_ = reader->ReadByte();
1320 stmt->expression_ = Expression::ReadFrom(reader); 1542 stmt->expression_ = Expression::ReadFrom(reader);
1543
1544 stmt->cannot_stream_ = stmt->expression_->cannot_stream();
1545
1321 return stmt; 1546 return stmt;
1322 } 1547 }
1323 1548
1324 1549
1325 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) { 1550 VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
1326 TRACE_READ_OFFSET(); 1551 TRACE_READ_OFFSET();
1327 Tag tag = reader->ReadTag(); 1552 Tag tag = reader->ReadTag();
1328 ASSERT(tag == kVariableDeclaration); 1553 ASSERT(tag == kVariableDeclaration);
1329 return VariableDeclaration::ReadFromImpl(reader, true); 1554 return VariableDeclaration::ReadFromImpl(reader, true);
1330 } 1555 }
(...skipping 14 matching lines...) Expand all
1345 decl->type_ = DartType::ReadFrom(reader); 1570 decl->type_ = DartType::ReadFrom(reader);
1346 decl->initializer_ = reader->ReadOptional<Expression>(); 1571 decl->initializer_ = reader->ReadOptional<Expression>();
1347 1572
1348 // Go to next token position so it ends *after* the last potentially 1573 // Go to next token position so it ends *after* the last potentially
1349 // debuggable position in the initializer. 1574 // debuggable position in the initializer.
1350 TokenPosition position = reader->max_position(); 1575 TokenPosition position = reader->max_position();
1351 if (position.IsReal()) position.Next(); 1576 if (position.IsReal()) position.Next();
1352 decl->end_position_ = position; 1577 decl->end_position_ = position;
1353 reader->helper()->variables().Push(decl); 1578 reader->helper()->variables().Push(decl);
1354 1579
1580 decl->cannot_stream_ =
1581 decl->initializer_ != NULL && decl->initializer_->cannot_stream();
1582
1355 return decl; 1583 return decl;
1356 } 1584 }
1357 1585
1358 1586
1359 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) { 1587 FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
1360 TRACE_READ_OFFSET(); 1588 TRACE_READ_OFFSET();
1361 FunctionDeclaration* decl = new FunctionDeclaration(); 1589 FunctionDeclaration* decl = new FunctionDeclaration();
1362 decl->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte. 1590 decl->kernel_offset_ = reader->offset() - 1; // -1 to include tag byte.
1363 decl->position_ = reader->ReadPosition(); 1591 decl->position_ = reader->ReadPosition();
1364 decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false); 1592 decl->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
1365 VariableScope<ReaderHelper> parameters(reader->helper()); 1593 VariableScope<ReaderHelper> parameters(reader->helper());
1366 decl->function_ = FunctionNode::ReadFrom(reader); 1594 decl->function_ = FunctionNode::ReadFrom(reader);
1595
1596 decl->cannot_stream_ = decl->variable_->cannot_stream() ||
1597 decl->function_->cannot_stream() || true;
1598
1367 return decl; 1599 return decl;
1368 } 1600 }
1369 1601
1370 1602
1371 Name* Name::ReadFrom(Reader* reader) { 1603 Name* Name::ReadFrom(Reader* reader) {
1372 intptr_t name_index = reader->ReadUInt(); 1604 intptr_t name_index = reader->ReadUInt();
1373 if ((reader->StringLength(name_index) >= 1) && 1605 if ((reader->StringLength(name_index) >= 1) &&
1374 (reader->CharacterAt(name_index, 0) == '_')) { 1606 (reader->CharacterAt(name_index, 0) == '_')) {
1375 CanonicalName* library_reference = reader->ReadCanonicalNameReference(); 1607 CanonicalName* library_reference = reader->ReadCanonicalNameReference();
1376 return new Name(name_index, library_reference); 1608 return new Name(name_index, library_reference);
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
1457 return type; 1689 return type;
1458 } 1690 }
1459 1691
1460 1692
1461 FunctionType* FunctionType::ReadFrom(Reader* reader) { 1693 FunctionType* FunctionType::ReadFrom(Reader* reader) {
1462 TRACE_READ_OFFSET(); 1694 TRACE_READ_OFFSET();
1463 FunctionType* type = new FunctionType(); 1695 FunctionType* type = new FunctionType();
1464 TypeParameterScope<ReaderHelper> scope(reader->helper()); 1696 TypeParameterScope<ReaderHelper> scope(reader->helper());
1465 type->type_parameters().ReadFrom(reader); 1697 type->type_parameters().ReadFrom(reader);
1466 type->required_parameter_count_ = reader->ReadUInt(); 1698 type->required_parameter_count_ = reader->ReadUInt();
1699 intptr_t total_parameter_count = reader->ReadUInt();
1467 type->positional_parameters().ReadFromStatic<DartType>(reader); 1700 type->positional_parameters().ReadFromStatic<DartType>(reader);
1468 type->named_parameters().ReadFromStatic<NamedParameter>(reader); 1701 type->named_parameters().ReadFromStatic<NamedParameter>(reader);
1702 ASSERT(type->positional_parameters().length() +
1703 type->named_parameters().length() ==
1704 total_parameter_count);
1469 type->return_type_ = DartType::ReadFrom(reader); 1705 type->return_type_ = DartType::ReadFrom(reader);
1470 return type; 1706 return type;
1471 } 1707 }
1472 1708
1473 1709
1474 FunctionType* FunctionType::ReadFrom(Reader* reader, bool _is_simple_) { 1710 FunctionType* FunctionType::ReadFrom(Reader* reader, bool _is_simple_) {
1475 TRACE_READ_OFFSET(); 1711 TRACE_READ_OFFSET();
1476 FunctionType* type = new FunctionType(); 1712 FunctionType* type = new FunctionType();
1477 ASSERT(_is_simple_); 1713 ASSERT(_is_simple_);
1478 type->positional_parameters().ReadFromStatic<DartType>(reader); 1714 type->positional_parameters().ReadFromStatic<DartType>(reader);
1479 type->required_parameter_count_ = type->positional_parameters().length(); 1715 type->required_parameter_count_ = type->positional_parameters().length();
1480 type->return_type_ = DartType::ReadFrom(reader); 1716 type->return_type_ = DartType::ReadFrom(reader);
1481 return type; 1717 return type;
1482 } 1718 }
1483 1719
1484 1720
1485 TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) { 1721 TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) {
1486 TRACE_READ_OFFSET(); 1722 TRACE_READ_OFFSET();
1487 TypeParameterType* type = new TypeParameterType(); 1723 TypeParameterType* type = new TypeParameterType();
1488 type->parameter_ = 1724 type->parameter_ =
1489 reader->helper()->type_parameters().Lookup(reader->ReadUInt()); 1725 reader->helper()->type_parameters().Lookup(reader->ReadUInt());
1726 reader->ReadUInt(); // binary offset of parameter
1490 return type; 1727 return type;
1491 } 1728 }
1492 1729
1493 1730
1494 VectorType* VectorType::ReadFrom(Reader* reader) { 1731 VectorType* VectorType::ReadFrom(Reader* reader) {
1495 TRACE_READ_OFFSET(); 1732 TRACE_READ_OFFSET();
1496 VectorType* type = new VectorType(); 1733 VectorType* type = new VectorType();
1497 return type; 1734 return type;
1498 } 1735 }
1499 1736
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
1543 1780
1544 int libraries = reader->ReadUInt(); 1781 int libraries = reader->ReadUInt();
1545 program->libraries().EnsureInitialized(libraries); 1782 program->libraries().EnsureInitialized(libraries);
1546 for (intptr_t i = 0; i < libraries; i++) { 1783 for (intptr_t i = 0; i < libraries; i++) {
1547 program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader); 1784 program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader);
1548 } 1785 }
1549 1786
1550 program->main_method_reference_ = 1787 program->main_method_reference_ =
1551 Reference::ReadMemberFrom(reader, /*allow_null=*/true); 1788 Reference::ReadMemberFrom(reader, /*allow_null=*/true);
1552 1789
1790 program->cannot_stream_ = true;
1791
1553 return program; 1792 return program;
1554 } 1793 }
1555 1794
1556 1795
1557 FunctionNode* FunctionNode::ReadFrom(Reader* reader) { 1796 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
1558 TRACE_READ_OFFSET(); 1797 TRACE_READ_OFFSET();
1559 TypeParameterScope<ReaderHelper> scope(reader->helper()); 1798 TypeParameterScope<ReaderHelper> scope(reader->helper());
1560 1799
1561 FunctionNode* function = new FunctionNode(); 1800 FunctionNode* function = new FunctionNode();
1562 function->kernel_offset_ = reader->offset(); // FunctionNode has no tag. 1801 function->kernel_offset_ = reader->offset(); // FunctionNode has no tag.
1563 function->position_ = reader->ReadPosition(); 1802 function->position_ = reader->ReadPosition();
1564 function->end_position_ = reader->ReadPosition(); 1803 function->end_position_ = reader->ReadPosition();
1565 function->async_marker_ = 1804 function->async_marker_ =
1566 static_cast<FunctionNode::AsyncMarker>(reader->ReadByte()); 1805 static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
1567 function->dart_async_marker_ = 1806 function->dart_async_marker_ =
1568 static_cast<FunctionNode::AsyncMarker>(reader->ReadByte()); 1807 static_cast<FunctionNode::AsyncMarker>(reader->ReadByte());
1569 function->type_parameters().ReadFrom(reader); 1808 function->type_parameters().ReadFrom(reader);
1570 function->required_parameter_count_ = reader->ReadUInt(); 1809 function->required_parameter_count_ = reader->ReadUInt();
1571 function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>( 1810 function->positional_parameters().ReadFromStatic<VariableDeclarationImpl>(
1572 reader); 1811 reader);
1573 function->named_parameters().ReadFromStatic<VariableDeclarationImpl>(reader); 1812 function->named_parameters().ReadFromStatic<VariableDeclarationImpl>(reader);
1574 function->return_type_ = DartType::ReadFrom(reader); 1813 function->return_type_ = DartType::ReadFrom(reader);
1575 1814
1576 LabelScope<ReaderHelper, BlockStack<LabeledStatement> > labels( 1815 LabelScope<ReaderHelper, BlockStack<LabeledStatement> > labels(
1577 reader->helper()); 1816 reader->helper());
1578 VariableScope<ReaderHelper> vars(reader->helper()); 1817 VariableScope<ReaderHelper> vars(reader->helper());
1579 function->body_ = reader->ReadOptional<Statement>(); 1818 function->body_ = reader->ReadOptional<Statement>();
1819
1820 function->cannot_stream_ =
1821 function->positional_parameters_.cannot_stream() ||
1822 function->named_parameters_.cannot_stream() ||
1823 (function->body_ != NULL && function->body_->cannot_stream());
1824
1580 return function; 1825 return function;
1581 } 1826 }
1582 1827
1583 1828
1584 TypeParameter* TypeParameter::ReadFrom(Reader* reader) { 1829 TypeParameter* TypeParameter::ReadFrom(Reader* reader) {
1585 TRACE_READ_OFFSET(); 1830 TRACE_READ_OFFSET();
1831 kernel_offset_ = reader->offset();
1586 name_index_ = reader->ReadUInt(); 1832 name_index_ = reader->ReadUInt();
1587 bound_ = DartType::ReadFrom(reader); 1833 bound_ = DartType::ReadFrom(reader);
1588 return this; 1834 return this;
1589 } 1835 }
1590 1836
1591 1837
1592 } // namespace kernel 1838 } // namespace kernel
1593 1839
1594 1840
1595 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer, 1841 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
1596 intptr_t buffer_length) { 1842 intptr_t buffer_length) {
1597 kernel::Reader reader(buffer, buffer_length); 1843 kernel::Reader reader(buffer, buffer_length);
1598 return kernel::Program::ReadFrom(&reader); 1844 return kernel::Program::ReadFrom(&reader);
1599 } 1845 }
1600 1846
1601 1847
1602 } // namespace dart 1848 } // namespace dart
1603 #endif // !defined(DART_PRECOMPILED_RUNTIME) 1849 #endif // !defined(DART_PRECOMPILED_RUNTIME)
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698