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

Side by Side Diff: runtime/bin/gen_snapshot.cc

Issue 1411383004: Enable generation of instruction buffer on precompilation (Closed) Base URL: https://github.com/dart-lang/sdk.git@master
Patch Set: Created 5 years, 1 month 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) 2013, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2013, 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 4
5 // Generate a snapshot file after loading all the scripts specified on the 5 // Generate a snapshot file after loading all the scripts specified on the
6 // command line. 6 // command line.
7 7
8 #include <stdlib.h> 8 #include <stdlib.h>
9 #include <string.h> 9 #include <string.h>
10 #include <stdio.h> 10 #include <stdio.h>
(...skipping 20 matching lines...) Expand all
31 Dart_ExitScope(); \ 31 Dart_ExitScope(); \
32 Dart_ShutdownIsolate(); \ 32 Dart_ShutdownIsolate(); \
33 exit(255); \ 33 exit(255); \
34 } \ 34 } \
35 35
36 36
37 // Global state that indicates whether a snapshot is to be created and 37 // Global state that indicates whether a snapshot is to be created and
38 // if so which file to write the snapshot into. 38 // if so which file to write the snapshot into.
39 static const char* vm_isolate_snapshot_filename = NULL; 39 static const char* vm_isolate_snapshot_filename = NULL;
40 static const char* isolate_snapshot_filename = NULL; 40 static const char* isolate_snapshot_filename = NULL;
41 static const char* instructions_snapshot_filename = NULL;
42 static const char* vm_entry_points_manifest = NULL;
rmacnak 2015/10/21 23:06:18 Throughout: s/vm_entry_points/embedder_entry_point
Chinmay 2015/10/22 00:13:16 ack
41 static const char* package_root = NULL; 43 static const char* package_root = NULL;
42 44
43 45
44 // Global state which contains a pointer to the script name for which 46 // Global state which contains a pointer to the script name for which
45 // a snapshot needs to be created (NULL would result in the creation 47 // a snapshot needs to be created (NULL would result in the creation
46 // of a generic snapshot that contains only the corelibs). 48 // of a generic snapshot that contains only the corelibs).
47 static char* app_script_name = NULL; 49 static char* app_script_name = NULL;
48 50
49 51
50 // Global state that captures the URL mappings specified on the command line. 52 // Global state that captures the URL mappings specified on the command line.
(...skipping 30 matching lines...) Expand all
81 static bool ProcessIsolateSnapshotOption(const char* option) { 83 static bool ProcessIsolateSnapshotOption(const char* option) {
82 const char* name = ProcessOption(option, "--isolate_snapshot="); 84 const char* name = ProcessOption(option, "--isolate_snapshot=");
83 if (name != NULL) { 85 if (name != NULL) {
84 isolate_snapshot_filename = name; 86 isolate_snapshot_filename = name;
85 return true; 87 return true;
86 } 88 }
87 return false; 89 return false;
88 } 90 }
89 91
90 92
93 static bool ProcessInstructionsSnapshotOption(const char* option) {
94 const char* name = ProcessOption(option, "--instructions_snapshot=");
95 if (name != NULL) {
96 instructions_snapshot_filename = name;
97 return true;
98 }
99 return false;
100 }
101
102
103 static bool ProcessVMEntryPointsManifestOption(const char* option) {
104 const char* name = ProcessOption(option, "--vm_entry_points_manifest=");
105 if (name != NULL) {
106 vm_entry_points_manifest = name;
107 return true;
108 }
109 return false;
110 }
111
112
91 static bool ProcessPackageRootOption(const char* option) { 113 static bool ProcessPackageRootOption(const char* option) {
92 const char* name = ProcessOption(option, "--package_root="); 114 const char* name = ProcessOption(option, "--package_root=");
93 if (name != NULL) { 115 if (name != NULL) {
94 package_root = name; 116 package_root = name;
95 return true; 117 return true;
96 } 118 }
97 return false; 119 return false;
98 } 120 }
99 121
100 122
(...skipping 19 matching lines...) Expand all
120 const char* kPrefix = "--"; 142 const char* kPrefix = "--";
121 const intptr_t kPrefixLen = strlen(kPrefix); 143 const intptr_t kPrefixLen = strlen(kPrefix);
122 144
123 // Skip the binary name. 145 // Skip the binary name.
124 int i = 1; 146 int i = 1;
125 147
126 // Parse out the vm options. 148 // Parse out the vm options.
127 while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) { 149 while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
128 if (ProcessVmIsolateSnapshotOption(argv[i]) || 150 if (ProcessVmIsolateSnapshotOption(argv[i]) ||
129 ProcessIsolateSnapshotOption(argv[i]) || 151 ProcessIsolateSnapshotOption(argv[i]) ||
152 ProcessInstructionsSnapshotOption(argv[i]) ||
153 ProcessVMEntryPointsManifestOption(argv[i]) ||
130 ProcessURLmappingOption(argv[i]) || 154 ProcessURLmappingOption(argv[i]) ||
131 ProcessPackageRootOption(argv[i])) { 155 ProcessPackageRootOption(argv[i])) {
132 i += 1; 156 i += 1;
133 continue; 157 continue;
134 } 158 }
135 vm_options->AddArgument(argv[i]); 159 vm_options->AddArgument(argv[i]);
136 i += 1; 160 i += 1;
137 } 161 }
138 162
139 // Get the script name. 163 // Get the script name.
140 if (i < argc) { 164 if (i < argc) {
141 *script_name = argv[i]; 165 *script_name = argv[i];
142 i += 1; 166 i += 1;
143 } else { 167 } else {
144 *script_name = NULL; 168 *script_name = NULL;
145 } 169 }
146 170
147 if (vm_isolate_snapshot_filename == NULL) { 171 if (vm_isolate_snapshot_filename == NULL) {
148 Log::PrintErr("No vm isolate snapshot output file specified.\n\n"); 172 Log::PrintErr("No vm isolate snapshot output file specified.\n\n");
149 return -1; 173 return -1;
150 } 174 }
151 175
152 if (isolate_snapshot_filename == NULL) { 176 if (isolate_snapshot_filename == NULL) {
153 Log::PrintErr("No isolate snapshot output file specified.\n\n"); 177 Log::PrintErr("No isolate snapshot output file specified.\n\n");
154 return -1; 178 return -1;
155 } 179 }
156 180
181 if (instructions_snapshot_filename != NULL &&
182 vm_entry_points_manifest == NULL) {
183 Log::PrintErr(
184 "Specifying an instructions snapshot filename indicates "
185 "precompilation. But no VM entry points manifest was specified.\n\n");
186 return -1;
187 }
188
189 if (vm_entry_points_manifest != NULL &&
190 instructions_snapshot_filename == NULL) {
191 Log::PrintErr(
192 "Specifying the VM entry points manifest indicates precompilation. But "
193 "no instuctions snapshot was specified.\n\n");
194 return -1;
195 }
196
157 return 0; 197 return 0;
158 } 198 }
159 199
160 200
201 static bool IsSnapshottingForPrecompilation(void) {
202 return vm_entry_points_manifest != NULL &&
203 instructions_snapshot_filename != NULL;
204 }
205
206
161 static void WriteSnapshotFile(const char* filename, 207 static void WriteSnapshotFile(const char* filename,
162 const uint8_t* buffer, 208 const uint8_t* buffer,
163 const intptr_t size) { 209 const intptr_t size) {
164 File* file = File::Open(filename, File::kWriteTruncate); 210 File* file = File::Open(filename, File::kWriteTruncate);
165 ASSERT(file != NULL); 211 ASSERT(file != NULL);
166 if (!file->WriteFully(buffer, size)) { 212 if (!file->WriteFully(buffer, size)) {
167 Log::PrintErr("Error: Failed to write snapshot file.\n\n"); 213 Log::PrintErr("Error: Failed to write snapshot file.\n\n");
168 } 214 }
169 delete file; 215 delete file;
170 } 216 }
(...skipping 242 matching lines...) Expand 10 before | Expand all | Expand 10 after
413 Dart_Handle lib; 459 Dart_Handle lib;
414 // Load the builtin library to make it available in the snapshot 460 // Load the builtin library to make it available in the snapshot
415 // for importing. 461 // for importing.
416 lib = Builtin::LoadAndCheckLibrary(id); 462 lib = Builtin::LoadAndCheckLibrary(id);
417 ASSERT(!Dart_IsError(lib)); 463 ASSERT(!Dart_IsError(lib));
418 return lib; 464 return lib;
419 } 465 }
420 466
421 467
422 static void PrintUsage() { 468 static void PrintUsage() {
423 Log::PrintErr( 469 #define STRINGERIZE(...) #__VA_ARGS__
424 "Usage:\n" 470 // clang-format off
425 "\n" 471 Log::PrintErr(STRINGERIZE(
426 " gen_snapshot [<vm-flags>] [<options>] \\\n" 472 Usage: \n
427 " --snapshot=<out-file> [<dart-script-file>]\n" 473 gen_snapshot [<vm-flags>] [<options>] [<dart-script-file>] \n
428 "\n" 474 \n
429 " Writes a snapshot of <dart-script-file> to <out-file>. If no\n" 475 Writes a snapshot of <dart-script-file> to the specified snapshot files. If \n
430 " <dart-script-file> is passed, a generic snapshot of all the corelibs is\n" 476 no <dart-script-file> is passed, a generic snapshot of all the corelibs is \n
431 " created. It is required to specify an output file name:\n" 477 created. It is required to specify the VM isolate snapshot and the isolate \n
432 "\n" 478 snapshot. The other flags are related to precompilation and are optional. \n
433 " --snapshot=<file> Generates a complete snapshot. Uses the url\n" 479 \n
434 " mapping specified on the command line to load\n" 480 Precompilation: \n
435 " the libraries.\n" 481 In order to configure the snapshotter for precompilation, both the \n
436 "Supported options:\n" 482 instructions snapshot and the VM entry points manifest must be specified. \n
437 "\n" 483 Machine code for the target architecture will be dumped into the \n
438 "--package_root=<path>\n" 484 instructions snapshot. This must be linked into the target binary in a \n
439 " Where to find packages, that is, \"package:...\" imports.\n" 485 separate step. The VM entry points manifest lists the standalone entry \n
440 "\n" 486 points into the VM. Not specifying these will cause the tree shaker to \n
441 "--url_mapping=<mapping>\n" 487 disregard the same as being used. The format of this manifest is as follows.\n
442 " Uses the URL mapping(s) specified on the command line to load the\n" 488 Each line in the manifest is a comma separated list of three elements. The \n
443 " libraries. For use only with --snapshot=.\n"); 489 first entry is the library URI, the second entry is the class name and the \n
490 final entry the function name. The file must be terminated with a newline \n
491 charater. \n
492 \n
493 Example: \n
494 dart:something,SomeClass,doSomething \n
495 \n
496 Supported options: \n
497 --vm_isolate_snapshot=<file> A full snapshot is a compact \n
498 --isolate_snapshot=<file> representation of the dart vm isolate \n
499 heap and dart isolate heap states. \n
500 Both these options are required \n
501 \n
502 --package_root=<path> Where to find packages, that is, \n
503 package:... imports. \n
504 \n
505 --url_mapping=<mapping> Uses the URL mapping(s) specified on the\n
506 command line to load the libraries. \n
507 \n
508 --instructions_snapshot=<file> (Precompilation only) Contains the \n
509 machine code that must be linked into \n
rmacnak 2015/10/21 23:06:18 s/machine code/assembly
Chinmay 2015/10/22 00:13:16 ack
510 the target binary \n
511 \n
512 --vm_entry_points_manifest=<file> (Precompilation only) Contains the \n
513 stanalone VM entry points \n
514 ));
515 // clang-format on
516 #undef STRINGERIZE
444 } 517 }
445 518
446 519
447 static void VerifyLoaded(Dart_Handle library) { 520 static void VerifyLoaded(Dart_Handle library) {
448 if (Dart_IsError(library)) { 521 if (Dart_IsError(library)) {
449 const char* err_msg = Dart_GetError(library); 522 const char* err_msg = Dart_GetError(library);
450 Log::PrintErr("Errors encountered while loading: %s\n", err_msg); 523 Log::PrintErr("Errors encountered while loading: %s\n", err_msg);
451 Dart_ExitScope(); 524 Dart_ExitScope();
452 Dart_ShutdownIsolate(); 525 Dart_ShutdownIsolate();
453 exit(255); 526 exit(255);
454 } 527 }
455 ASSERT(Dart_IsLibrary(library)); 528 ASSERT(Dart_IsLibrary(library));
456 } 529 }
457 530
458 531
532 static const char StubNativeFunctionName[] = "StubNativeFunction";
533
534
535 void StubNativeFunction(Dart_NativeArguments arguments) {
536 // This is a stub function for the resolver
537 ASSERT(false);
rmacnak 2015/10/21 23:06:18 UNREACHABLE();
Chinmay 2015/10/22 00:13:16 ack
538 }
539
540
541 static Dart_NativeFunction StubNativeLookup(Dart_Handle name,
542 int argument_count,
Cutch 2015/10/21 22:00:08 align arguments
Chinmay 2015/10/22 00:13:17 ack
543 bool* auto_setup_scope) {
544 return &StubNativeFunction;
545 }
546
547
548 static const uint8_t* StubNativeSymbol(Dart_NativeFunction nf) {
549 return reinterpret_cast<const uint8_t *>(StubNativeFunctionName);
550 }
551
552
553 static void SetupStubNativeResolver(size_t lib_index,
rmacnak 2015/10/21 23:06:18 TODO(24686): Remove this.
Chinmay 2015/10/22 00:13:16 ack
554 const Dart_QualifiedFunctionName* entry) {
555 Dart_Handle library_string = Dart_NewStringFromCString(entry->library_uri);
556 DART_CHECK_VALID(library_string);
557 Dart_Handle library = Dart_LookupLibrary(library_string);
558 // VM entry points may be setup in libraries that have not been explicitly
559 // loaded by the application script. In such cases, library lookup will
560 // fail. Manually load those libraries.
561 if (Dart_IsError(library)) {
562 static const uint32_t kLoadBufferMaxSize = 128;
563 char* load_buffer =
564 reinterpret_cast<char*>(calloc(kLoadBufferMaxSize, sizeof(char)));
565 snprintf(load_buffer,
566 kLoadBufferMaxSize,
567 "import '%s';",
568 DartUtils::GetStringValue(library_string));
569 Dart_Handle script_handle = Dart_NewStringFromCString(load_buffer);
570 memset(load_buffer, 0, kLoadBufferMaxSize);
571 snprintf(load_buffer,
572 kLoadBufferMaxSize,
573 "dart:_snapshot_%zu",
574 lib_index);
575 Dart_Handle script_url = Dart_NewStringFromCString(load_buffer);
576 free(load_buffer);
577 Dart_Handle loaded = Dart_LoadLibrary(script_url, script_handle, 0, 0);
578 DART_CHECK_VALID(loaded);
579
580 // Do a fresh lookup
581 library = Dart_LookupLibrary(library_string);
582 }
583
584 DART_CHECK_VALID(library);
585 Dart_Handle result = Dart_SetNativeResolver(library,
586 &StubNativeLookup,
587 &StubNativeSymbol);
588 DART_CHECK_VALID(result);
589 }
590
591
592 static void ImportNativeEntryPointLibrariesIntoRoot(
593 const Dart_QualifiedFunctionName* entries) {
594 if (entries == nullptr) {
rmacnak 2015/10/21 23:06:18 Here and throughout s/nullptr/NULL nullptr is und
Chinmay 2015/10/22 00:13:17 ack
595 return;
596 }
597
598 size_t index = 0;
599 while (true) {
600 Dart_QualifiedFunctionName entry = entries[index++];
601 if (entry.library_uri == nullptr) {
602 // The termination sentinel has null members.
603 break;
604 }
605 Dart_Handle entry_library =
606 Dart_LookupLibrary(Dart_NewStringFromCString(entry.library_uri));
607 DART_CHECK_VALID(entry_library);
608 Dart_Handle import_result = Dart_LibraryImportLibrary(
609 entry_library, Dart_RootLibrary(), Dart_EmptyString());
610 DART_CHECK_VALID(import_result);
611 }
612 }
613
614
615 static void SetupStubNativeResolversForPrecompilation(
616 const Dart_QualifiedFunctionName* entries) {
617
618 if (entries == nullptr) {
619 return;
620 }
621
622 // Setup native resolvers for all libraries found in the manifest.
623 size_t index = 0;
624 while (true) {
625 Dart_QualifiedFunctionName entry = entries[index++];
626 if (entry.library_uri == nullptr) {
627 // The termination sentinel has null members.
628 break;
629 }
630 // Setup stub resolvers on loaded libraries
631 SetupStubNativeResolver(index, &entry);
632 }
633 }
634
635
636 static bool ParseEntryPointsManifestSingleLine(
Cutch 2015/10/21 22:00:08 This should take an char** error which indicates w
Chinmay 2015/10/22 00:13:16 ack
637 const char* line, Dart_QualifiedFunctionName* entry) {
638 bool success = true;
639 size_t offset = 0;
640 for (uint8_t i = 0; i < 3; i++) {
641 char* component = strchr(line + offset, i == 2 ? '\n' : ',');
rmacnak 2015/10/21 23:06:18 const char* component
Chinmay 2015/10/22 00:13:16 ack
642 if (component == nullptr) {
643 success = false;
644 break;
645 }
646
647 int64_t chars_read = component - (line + offset);
648 if (chars_read <= 0) {
649 success = false;
650 break;
651 }
652
653 if (entry != nullptr) {
654 // These allocations are collected in |CleanupEntryPointsCollection|.
655 char* entry_item =
656 reinterpret_cast<char*>(calloc(chars_read + 1, sizeof(char)));
657 memcpy(entry_item, line + offset, chars_read);
658
659 switch (i) {
660 case 0: // library
661 entry->library_uri = entry_item;
662 break;
663 case 1: // class
664 entry->class_name = entry_item;
665 break;
666 case 2: // function
667 entry->function_name = entry_item;
668 break;
669 default:
670 free(entry_item);
671 success = false;
672 break;
673 }
674 }
675
676 offset += chars_read + 1;
677 }
678 return success;
679 }
680
681
682 int64_t ParseEntryPointsManifestLines(FILE* file,
683 Dart_QualifiedFunctionName* collection) {
684 int64_t entries = 0;
685
686 static const int kManifestMaxLineLength = 1024;
687 char* line = reinterpret_cast<char*>(malloc(kManifestMaxLineLength));
688
689 while (true) {
690 char* read_line = fgets(line, kManifestMaxLineLength, file);
691
692 if (read_line == nullptr) {
693 if ((feof(file) != 0) && (ferror(file) != 0)) {
694 entries = -1;
695 }
696 break;
697 }
698
699 Dart_QualifiedFunctionName* entry =
700 collection != nullptr ? collection + entries : nullptr;
701
702 if (!ParseEntryPointsManifestSingleLine(read_line, entry)) {
703 entries = -1;
Cutch 2015/10/21 22:00:08 This might leak some |entry_item| allocated above
Chinmay 2015/10/22 00:13:16 ack
704 break;
705 }
706
707 entries++;
708 }
709
710 free(line);
711
712 return entries;
713 }
714
715
716 static Dart_QualifiedFunctionName* ParseEntryPointsManifestFile(
717 const char* path) {
718 if (path == nullptr) {
719 return nullptr;
720 }
721
722 FILE* file = fopen(path, "r");
723
724 if (file == nullptr) {
725 Log::PrintErr("Could not open entry points manifest file\n");
726 return nullptr;
727 }
728
729 // Parse the file once but don't store the results. This is done to first
730 // determine the number of entries in the manifest
731 int64_t entry_count = ParseEntryPointsManifestLines(file, nullptr);
732
733 if (entry_count <= 0) {
734 Log::PrintErr("Manifest file specified is invalid or contained no entries");
735 fclose(file);
736 return nullptr;
737 }
738
739 rewind(file);
740
741 // Allocate enough storage for the entries in the file plus a termination
742 // sentinel and parse it again to populate the allocation
743 Dart_QualifiedFunctionName* entries =
744 reinterpret_cast<Dart_QualifiedFunctionName*>(
745 calloc(entry_count + 1, sizeof(Dart_QualifiedFunctionName)));
746
747 int64_t parsed_entry_count = ParseEntryPointsManifestLines(file, entries);
748
749 if (parsed_entry_count != entry_count) {
Cutch 2015/10/21 22:00:08 You're calling the same function twice with the sa
Chinmay 2015/10/22 00:13:17 Was being paranoid since I am reading from a file
750 free(entries);
Cutch 2015/10/21 22:00:08 This leaks pointers inside of |entries|. Call Clea
Chinmay 2015/10/22 00:13:17 ack. Removed by the assert.
751 fclose(file);
752 return nullptr;
753 }
754
755 fclose(file);
756
757 // The entries allocation must be explicitly cleaned up via
758 // |CleanupEntryPointsCollection|
759 return entries;
760 }
761
762
763 static Dart_QualifiedFunctionName* ParseEntryPointsManifestIfPresent() {
764 Dart_QualifiedFunctionName* entries =
765 ParseEntryPointsManifestFile(vm_entry_points_manifest);
766 if (entries == nullptr && IsSnapshottingForPrecompilation()) {
Cutch 2015/10/21 22:00:08 s/nullptr/NULL here and elsewhere
Chinmay 2015/10/22 00:13:16 ack
767 Log::PrintErr(
768 "Could not find native VM entry points during precompilation");
769 exit(255);
770 }
771 return entries;
772 }
773
774
775 void CleanupEntryPointsCollection(Dart_QualifiedFunctionName* entries) {
776 if (entries == nullptr) {
777 return;
778 }
779
780 size_t index = 0;
781 while (true) {
782 Dart_QualifiedFunctionName entry = entries[index++];
783 if (entry.library_uri == nullptr) {
Cutch 2015/10/21 22:00:08 s/nullptr/NULL here and elsewhere
Chinmay 2015/10/22 00:13:16 ack
784 break;
785 }
786 free((char*)entry.library_uri);
Cutch 2015/10/21 22:00:08 use c++ casts
Chinmay 2015/10/22 00:13:17 ack
787 free((char*)entry.class_name);
788 free((char*)entry.function_name);
789 }
790 free(entries);
791 }
792
793
459 static void CreateAndWriteSnapshot() { 794 static void CreateAndWriteSnapshot() {
460 Dart_Handle result; 795 Dart_Handle result;
461 uint8_t* vm_isolate_buffer = NULL; 796 uint8_t* vm_isolate_buffer = NULL;
462 intptr_t vm_isolate_size = 0; 797 intptr_t vm_isolate_size = 0;
463 uint8_t* isolate_buffer = NULL; 798 uint8_t* isolate_buffer = NULL;
464 intptr_t isolate_size = 0; 799 intptr_t isolate_size = 0;
465 800
466 // First create a snapshot. 801 // First create a snapshot.
467 result = Dart_CreateSnapshot(&vm_isolate_buffer, 802 result = Dart_CreateSnapshot(&vm_isolate_buffer,
468 &vm_isolate_size, 803 &vm_isolate_size,
469 &isolate_buffer, 804 &isolate_buffer,
470 &isolate_size); 805 &isolate_size);
471 CHECK_RESULT(result); 806 CHECK_RESULT(result);
472 807
473 // Now write the vm isolate and isolate snapshots out to the 808 // Now write the vm isolate and isolate snapshots out to the
474 // specified file and exit. 809 // specified file and exit.
475 WriteSnapshotFile(vm_isolate_snapshot_filename, 810 WriteSnapshotFile(vm_isolate_snapshot_filename,
476 vm_isolate_buffer, 811 vm_isolate_buffer,
477 vm_isolate_size); 812 vm_isolate_size);
478 WriteSnapshotFile(isolate_snapshot_filename, 813 WriteSnapshotFile(isolate_snapshot_filename,
479 isolate_buffer, 814 isolate_buffer,
480 isolate_size); 815 isolate_size);
481 Dart_ExitScope(); 816 Dart_ExitScope();
482 817
483 // Shutdown the isolate. 818 // Shutdown the isolate.
484 Dart_ShutdownIsolate(); 819 Dart_ShutdownIsolate();
485 } 820 }
486 821
487 822
823 static void CreateAndWritePrecompiledSnapshot(
824 Dart_QualifiedFunctionName* standalone_entry_points) {
825
826 if (standalone_entry_points == nullptr) {
Cutch 2015/10/21 22:00:08 Can you hoist this out or rename it? It's confusin
Chinmay 2015/10/22 00:13:16 ack
827 ASSERT(!IsSnapshottingForPrecompilation());
828 CreateAndWriteSnapshot();
829 return;
830 }
831
832 Dart_Handle result;
833 uint8_t* vm_isolate_buffer = NULL;
834 intptr_t vm_isolate_size = 0;
835 uint8_t* isolate_buffer = NULL;
836 intptr_t isolate_size = 0;
837 uint8_t* instructions_buffer = NULL;
838 intptr_t instructions_size = 0;
839
840 // Precompile with specified VM entry points
841 result = Dart_Precompile(standalone_entry_points, true);
842 CHECK_RESULT(result);
843
844 // Create a precompiled snapshot. This gives us an instruction buffer with
845 // machine code
846 result = Dart_CreatePrecompiledSnapshot(&vm_isolate_buffer,
847 &vm_isolate_size,
848 &isolate_buffer,
849 &isolate_size,
850 &instructions_buffer,
851 &instructions_size);
852 CHECK_RESULT(result);
853
854 // Now write the vm isolate, isolate and instructions snapshots out to the
855 // specified files and exit.
856 WriteSnapshotFile(vm_isolate_snapshot_filename,
857 vm_isolate_buffer,
858 vm_isolate_size);
859 WriteSnapshotFile(isolate_snapshot_filename,
860 isolate_buffer,
861 isolate_size);
862 WriteSnapshotFile(instructions_snapshot_filename,
863 instructions_buffer,
864 instructions_size);
865 Dart_ExitScope();
866
867 // Shutdown the isolate.
868 Dart_ShutdownIsolate();
869 }
870
871
488 static void SetupForUriResolution() { 872 static void SetupForUriResolution() {
489 // Set up the library tag handler for this isolate. 873 // Set up the library tag handler for this isolate.
490 Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler); 874 Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
491 if (Dart_IsError(result)) { 875 if (Dart_IsError(result)) {
492 Log::PrintErr("%s", Dart_GetError(result)); 876 Log::PrintErr("%s", Dart_GetError(result));
493 Dart_ExitScope(); 877 Dart_ExitScope();
494 Dart_ShutdownIsolate(); 878 Dart_ShutdownIsolate();
495 exit(255); 879 exit(255);
496 } 880 }
497 // This is a generic dart snapshot which needs builtin library setup. 881 // This is a generic dart snapshot which needs builtin library setup.
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
582 966
583 Thread::InitOnce(); 967 Thread::InitOnce();
584 DartUtils::SetOriginalWorkingDirectory(); 968 DartUtils::SetOriginalWorkingDirectory();
585 // Start event handler. 969 // Start event handler.
586 EventHandler::Start(); 970 EventHandler::Start();
587 971
588 vm_options.AddArgument("--load_deferred_eagerly"); 972 vm_options.AddArgument("--load_deferred_eagerly");
589 // Workaround until issue 21620 is fixed. 973 // Workaround until issue 21620 is fixed.
590 // (https://github.com/dart-lang/sdk/issues/21620) 974 // (https://github.com/dart-lang/sdk/issues/21620)
591 vm_options.AddArgument("--no-concurrent_sweep"); 975 vm_options.AddArgument("--no-concurrent_sweep");
976
977 if (IsSnapshottingForPrecompilation()) {
978 vm_options.AddArgument("--precompilation");
979 vm_options.AddArgument("--write_protect_code=false");
rmacnak 2015/10/21 23:06:18 --write_protect_code=false should be unnecessary n
Chinmay 2015/10/22 00:13:16 ack
980 }
981
592 Dart_SetVMFlags(vm_options.count(), vm_options.arguments()); 982 Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
593 983
594 // Initialize the Dart VM. 984 // Initialize the Dart VM.
595 // Note: We don't expect isolates to be created from dart code during 985 // Note: We don't expect isolates to be created from dart code during
596 // snapshot generation. 986 // snapshot generation.
597 char* error = Dart_Initialize( 987 char* error = Dart_Initialize(
598 NULL, 988 NULL,
599 NULL, 989 NULL,
600 CreateServiceIsolate, 990 CreateServiceIsolate,
601 NULL, 991 NULL,
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
665 fprintf(stderr, "%s", error); 1055 fprintf(stderr, "%s", error);
666 free(error); 1056 free(error);
667 exit(255); 1057 exit(255);
668 } 1058 }
669 Dart_EnterScope(); 1059 Dart_EnterScope();
670 1060
671 // Set up the library tag handler in such a manner that it will use the 1061 // Set up the library tag handler in such a manner that it will use the
672 // URL mapping specified on the command line to load the libraries. 1062 // URL mapping specified on the command line to load the libraries.
673 result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler); 1063 result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler);
674 CHECK_RESULT(result); 1064 CHECK_RESULT(result);
1065
1066 Dart_QualifiedFunctionName* entry_points =
1067 ParseEntryPointsManifestIfPresent();
1068
1069 SetupStubNativeResolversForPrecompilation(entry_points);
1070
675 // Load the specified script. 1071 // Load the specified script.
676 library = LoadSnapshotCreationScript(app_script_name); 1072 library = LoadSnapshotCreationScript(app_script_name);
677 VerifyLoaded(library); 1073 VerifyLoaded(library);
1074
1075 ImportNativeEntryPointLibrariesIntoRoot(entry_points);
1076
678 // Ensure that we mark all libraries as loaded. 1077 // Ensure that we mark all libraries as loaded.
679 result = Dart_FinalizeLoading(false); 1078 result = Dart_FinalizeLoading(false);
680 CHECK_RESULT(result); 1079 CHECK_RESULT(result);
681 CreateAndWriteSnapshot(); 1080 CreateAndWritePrecompiledSnapshot(entry_points);
1081
1082 CleanupEntryPointsCollection(entry_points);
682 1083
683 Dart_EnterIsolate(UriResolverIsolateScope::isolate); 1084 Dart_EnterIsolate(UriResolverIsolateScope::isolate);
684 Dart_ShutdownIsolate(); 1085 Dart_ShutdownIsolate();
685 } else { 1086 } else {
686 SetupForGenericSnapshotCreation(); 1087 SetupForGenericSnapshotCreation();
687 CreateAndWriteSnapshot(); 1088 CreateAndWriteSnapshot();
688 } 1089 }
689 EventHandler::Stop(); 1090 EventHandler::Stop();
690 return 0; 1091 return 0;
691 } 1092 }
692 1093
693 } // namespace bin 1094 } // namespace bin
694 } // namespace dart 1095 } // namespace dart
695 1096
696 int main(int argc, char** argv) { 1097 int main(int argc, char** argv) {
697 return dart::bin::main(argc, argv); 1098 return dart::bin::main(argc, argv);
698 } 1099 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698