Add option to gen_snapshot for creating a Makefile describing a snapshot's dependencies.

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <cstdarg>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/file.h"
 #include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 
 #include "platform/hashmap.h"
 #include "platform/globals.h"
+#include "platform/growable_array.h"
 
 namespace dart {
 namespace bin {
 
 // Exit code indicating an API error.
 static const int kApiErrorExitCode = 253;
 // Exit code indicating a compilation error.
 static const int kCompilationErrorExitCode = 254;
 // Exit code indicating an unhandled error that is not a compilation error.
 static const int kErrorExitCode = 255;
@@ skipping 20 matching lines @@
 
 
 // The core snapshot to use when creating isolates. Normally NULL, but loaded
 // from a file when creating script snapshots.
 const uint8_t* isolate_snapshot_data = NULL;
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 enum SnapshotKind {
+  kNone,
   kCore,
   kScript,
   kAppAOTBlobs,
   kAppAOTAssembly,
 };
 static SnapshotKind snapshot_kind = kCore;
 static const char* vm_snapshot_data_filename = NULL;
 static const char* vm_snapshot_instructions_filename = NULL;
 static const char* isolate_snapshot_data_filename = NULL;
 static const char* isolate_snapshot_instructions_filename = NULL;
 static const char* assembly_filename = NULL;
 static const char* script_snapshot_filename = NULL;
+static const char* dependencies_filename = NULL;
 
 
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
@@ skipping 109 matching lines @@
   }
   return NULL;
 }
 
 
 static bool ProcessSnapshotKindOption(const char* option) {
   const char* kind = ProcessOption(option, "--snapshot_kind=");
   if (kind == NULL) {
     return false;
   }
-  if (strcmp(kind, "core") == 0) {
+  if (strcmp(kind, "none") == 0) {
+    snapshot_kind = kNone;
+    return true;
+  } else if (strcmp(kind, "core") == 0) {
     snapshot_kind = kCore;
     return true;
   } else if (strcmp(kind, "script") == 0) {
     snapshot_kind = kScript;
     return true;
   } else if (strcmp(kind, "app-aot-blobs") == 0) {
     snapshot_kind = kAppAOTBlobs;
     return true;
   } else if (strcmp(kind, "app-aot-assembly") == 0) {
     snapshot_kind = kAppAOTAssembly;
@@ skipping 60 matching lines @@
 static bool ProcessScriptSnapshotOption(const char* option) {
   const char* name = ProcessOption(option, "--script_snapshot=");
   if (name != NULL) {
     script_snapshot_filename = name;
     return true;
   }
   return false;
 }
 
 
+static bool ProcessDependenciesOption(const char* option) {
+  const char* name = ProcessOption(option, "--dependencies=");
+  if (name != NULL) {
+    dependencies_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
   if (name != NULL) {
     entry_points_files->AddArgument(name);
     return true;
   }
   return false;
 }
 
 
@@ skipping 52 matching lines @@
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
     if (ProcessSnapshotKindOption(argv[i]) ||
         ProcessVmSnapshotDataOption(argv[i]) ||
         ProcessVmSnapshotInstructionsOption(argv[i]) ||
         ProcessIsolateSnapshotDataOption(argv[i]) ||
         ProcessIsolateSnapshotInstructionsOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
         ProcessScriptSnapshotOption(argv[i]) ||
+        ProcessDependenciesOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
         ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
         ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
       i += 1;
       continue;
     }
     vm_options->AddArgument(argv[i]);
     i += 1;
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
     i += 1;
   } else {
     *script_name = NULL;
   }
 
   // Verify consistency of arguments.
   if ((commandline_package_root != NULL) &&
       (commandline_packages_file != NULL)) {
     Log::PrintErr(
         "Specifying both a packages directory and a packages "
         "file is invalid.\n\n");
     return -1;
   }
 
   switch (snapshot_kind) {
+    case kNone: {
+      if (*script_name == NULL) {
+        Log::PrintErr(
+            "Building without snapshot generation requires a Dart "
+            "script.\n\n");
+        return -1;
+      }
+      break;
+    }
     case kCore: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL)) {
         Log::PrintErr(
             "Building a core snapshot requires specifying output files for "
             "--vm_snapshot_data and --isolate_snapshot_data.\n\n");
         return -1;
       }
       break;
     }
     case kScript: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL) ||
-          (script_snapshot_filename == NULL) || (script_name == NULL)) {
+          (script_snapshot_filename == NULL) || (*script_name == NULL)) {
         Log::PrintErr(
             "Building a script snapshot requires specifying input files for "
             "--vm_snapshot_data and --isolate_snapshot_data, an output file "
             "for --script-snapshot, and a Dart script.\n\n");
         return -1;
       }
       break;
     }
     case kAppAOTBlobs: {
       if ((vm_snapshot_data_filename == NULL) ||
           (vm_snapshot_instructions_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL) ||
           (isolate_snapshot_instructions_filename == NULL) ||
-          (script_name == NULL)) {
+          (*script_name == NULL)) {
         Log::PrintErr(
             "Building an AOT snapshot as blobs requires specifying output "
             "files for --vm_snapshot_data, --vm_snapshot_instructions, "
             "--isolate_snapshot_data and --isolate_snapshot_instructions and a "
             "Dart script.\n\n");
         return -1;
       }
       break;
     }
     case kAppAOTAssembly: {
-      if ((assembly_filename == NULL) || (script_name == NULL)) {
+      if ((assembly_filename == NULL) || (*script_name == NULL)) {
         Log::PrintErr(
             "Building an AOT snapshot as assembly requires specifying "
             "an output file for --assembly and a Dart script.\n\n");
         return -1;
       }
       break;
     }
   }
 
   if (IsSnapshottingForPrecompilation() && (entry_points_files->count() == 0)) {
@@ skipping 54 matching lines @@
  private:
   Dart_Isolate snapshotted_isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(UriResolverIsolateScope);
 };
 
 
 Dart_Isolate UriResolverIsolateScope::isolate = NULL;
 
 
+static char* ResolveAsFilePath(const char* uri_string) {
+  UriResolverIsolateScope scope;
+  uint8_t* scoped_file_path = NULL;
+  intptr_t scoped_file_path_length = -1;
+  Dart_Handle uri = Dart_NewStringFromCString(uri_string);
+  ASSERT(!Dart_IsError(uri));
+  Dart_Handle result = Loader::ResolveAsFilePath(uri, &scoped_file_path,
+                                                 &scoped_file_path_length);
+  if (Dart_IsError(result)) {
+    Log::Print("Error resolving dependency: %s\n", Dart_GetError(result));
+    exit(kErrorExitCode);
+  }
+  return StringUtils::StrNDup(reinterpret_cast<const char*>(scoped_file_path),
+                              scoped_file_path_length);
+}
+
+
+static void AddDependency(const char* uri_string) {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
+  if (dependencies != NULL) {
+    dependencies->Add(ResolveAsFilePath(uri_string));
+  }
+}
+
+
 static Dart_Handle LoadUrlContents(const char* uri_string) {
   bool failed = false;
-  char* result_string = NULL;
+  char* error_string = NULL;
   uint8_t* payload = NULL;
   intptr_t payload_length = 0;
   // Switch to the UriResolver Isolate and load the script.
   {
     UriResolverIsolateScope scope;
 
     Dart_Handle resolved_uri = Dart_NewStringFromCString(uri_string);
     Dart_Handle result =
         Loader::LoadUrlContents(resolved_uri, &payload, &payload_length);
     if (Dart_IsError(result)) {
       failed = true;
-      result_string = strdup(Dart_GetError(result));
+      error_string = strdup(Dart_GetError(result));
     }
   }
+  AddDependency(uri_string);
   // Switch back to the isolate from which we generate the snapshot and
   // create the source string for the specified uri.
   Dart_Handle result;
   if (!failed) {
     result = Dart_NewStringFromUTF8(payload, payload_length);
     free(payload);
   } else {
-    result = Dart_NewApiError(result_string);
-    free(result_string);
+    result = Dart_NewApiError(error_string);
+    free(error_string);
   }
   return result;
 }
 
 
 static Dart_Handle ResolveUriInWorkingDirectory(const char* script_uri) {
   bool failed = false;
   char* result_string = NULL;
 
   {
@@ skipping 44 matching lines @@
   if (DartUtils::IsDartBuiltinLibURL(url)) {
     return Builtin::kBuiltinLibrary;
   }
   if (DartUtils::IsDartIOLibURL(url)) {
     return Builtin::kIOLibrary;
   }
   return Builtin::kInvalidLibrary;
 }
 
 
+static void CreateAndWriteDependenciesFile() {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
+  if (dependencies == NULL) {
+    return;
+  }
+
+  ASSERT(dependencies_filename != NULL);
+  File* file = File::Open(dependencies_filename, File::kWriteTruncate);
+  if (file == NULL) {
+    Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
+                  dependencies_filename);
+    exit(kErrorExitCode);
+  }
+  bool success = true;
+
+  // Targets:
+  if (vm_snapshot_data_filename != NULL) {
+    success &=
+        file->Print("%s ", File::GetCanonicalPath(vm_snapshot_data_filename));
+  }
+  if (vm_snapshot_instructions_filename != NULL) {
+    success &= file->Print(
+        "%s ", File::GetCanonicalPath(vm_snapshot_instructions_filename));
+  }
+  if (isolate_snapshot_data_filename != NULL) {
+    success &= file->Print(
+        "%s ", File::GetCanonicalPath(isolate_snapshot_data_filename));
+  }
+  if (isolate_snapshot_instructions_filename != NULL) {
+    success &= file->Print(
+        "%s ", File::GetCanonicalPath(isolate_snapshot_instructions_filename));
+  }
+  if (assembly_filename != NULL) {
+    success &= file->Print("%s ", File::GetCanonicalPath(assembly_filename));
+  }
+  if (script_snapshot_filename != NULL) {
+    success &=
+        file->Print("%s ", File::GetCanonicalPath(script_snapshot_filename));
+  }
+
+  success &= file->Print(": ");
+
+  // Sources:
+  for (intptr_t i = 0; i < dependencies->length(); i++) {
+    char* dep = dependencies->At(i);
+    success &= file->Print("%s ", dep);
+    free(dep);
+  }
+  success &= file->Print("\n");
+
+  if (!success) {
+    Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
+                  dependencies_filename);
+    exit(kErrorExitCode);
+  }
+  file->Release();
+  delete dependencies;
+  isolate_data->set_dependencies(NULL);
+}
+
+
 static Dart_Handle CreateSnapshotLibraryTagHandler(Dart_LibraryTag tag,
                                                    Dart_Handle library,
                                                    Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   Dart_Handle library_url = Dart_LibraryUrl(library);
   if (Dart_IsError(library_url)) {
     return Dart_NewApiError("accessing library url failed");
   }
@@ skipping 81 matching lines @@
 }
 
 
 // clang-format off
 static void PrintUsage() {
   Log::PrintErr(
 "Usage:                                                                      \n"
 " gen_snapshot [<vm-flags>] [<options>] [<dart-script-file>]                 \n"
 "                                                                            \n"
 " Global options:                                                            \n"
-"   --package_root=<path>             Where to find packages, that is,       \n"
-"                                     package:...  imports.                  \n"
+"   --package_root=<path>         Where to find packages, that is,           \n"
+"                                 package:...  imports.                      \n"
 "                                                                            \n"
-"   --packages=<packages_file>        Where to find a package spec file      \n"
+"   --packages=<packages_file>    Where to find a package spec file          \n"
 "                                                                            \n"
-"   --url_mapping=<mapping>           Uses the URL mapping(s) specified on   \n"
-"                                     the command line to load the           \n"
-"                                     libraries.                             \n"
+"   --url_mapping=<mapping>       Uses the URL mapping(s) specified on       \n"
+"                                 the command line to load the               \n"
+"                                 libraries.                                 \n"
+"   --dependencies=<output-file>  Generates a Makefile with snapshot output  \n"
+"                                 files as targets and all transitive imports\n"
+"                                 as sources.                                \n"
+"                                                                            \n"
+" To discover dependencies without generating a snapshot:                    \n"
+"   --snapshot_kind=none                                                     \n"
+"   --dependencies=<output-file>                                             \n"
+"   <dart-script-file>                                                       \n"
 "                                                                            \n"
 " To create a core snapshot:                                                 \n"
 "   --snapshot_kind=core                                                     \n"
 "   --vm_snapshot_data=<output-file>                                         \n"
 "   --isolate_snapshot_data=<output-file>                                    \n"
 "   [<dart-script-file>]                                                     \n"
 "                                                                            \n"
 " Writes a snapshot of <dart-script-file> to the specified snapshot files.   \n"
 " If no <dart-script-file> is passed, a generic snapshot of all the corelibs \n"
 " is created.                                                                \n"
@@ skipping 623 matching lines @@
     File* file = File::Open(vm_snapshot_data_filename, File::kRead);
     if (file == NULL) {
       Log::PrintErr("Failed to open: %s\n", vm_snapshot_data_filename);
       return kErrorExitCode;
     }
     mapped_vm_snapshot_data = file->Map(File::kReadOnly, 0, file->Length());
     if (mapped_vm_snapshot_data == NULL) {
       Log::PrintErr("Failed to read: %s\n", vm_snapshot_data_filename);
       return kErrorExitCode;
     }
-    file->Close();
+    file->Release();
     init_params.vm_snapshot_data =
         reinterpret_cast<const uint8_t*>(mapped_vm_snapshot_data->address());
 
     file = File::Open(isolate_snapshot_data_filename, File::kRead);
     if (file == NULL) {
       Log::PrintErr("Failed to open: %s\n", isolate_snapshot_data_filename);
       return kErrorExitCode;
     }
     mapped_isolate_snapshot_data =
         file->Map(File::kReadOnly, 0, file->Length());
     if (mapped_isolate_snapshot_data == NULL) {
       Log::PrintErr("Failed to read: %s\n", isolate_snapshot_data_filename);
       return kErrorExitCode;
     }
-    file->Close();
+    file->Release();
     isolate_snapshot_data = reinterpret_cast<const uint8_t*>(
         mapped_isolate_snapshot_data->address());
   }
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return kErrorExitCode;
   }
@@ skipping 46 matching lines @@
     Dart_ExitIsolate();
 
     // Now we create an isolate into which we load all the code that needs to
     // be in the snapshot.
     isolate_data = new IsolateData(NULL, NULL, NULL, NULL);
     const uint8_t* kernel = NULL;
     intptr_t kernel_length = 0;
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
 
+    if (dependencies_filename != NULL) {
+      isolate_data->set_dependencies(new MallocGrowableArray<char*>());
+    }
+
     void* kernel_program = NULL;
     if (is_kernel_file) {
       kernel_program = Dart_ReadKernelBinary(kernel, kernel_length);
       free(const_cast<uint8_t*>(kernel));
     }
 
     Dart_Isolate isolate =
         is_kernel_file
             ? Dart_CreateIsolateFromKernel(NULL, NULL, kernel_program, NULL,
                                            isolate_data, &error)
             : Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data, NULL, NULL,
                                  isolate_data, &error);
     if (isolate == NULL) {
       Log::PrintErr("%s\n", error);
       free(error);
       exit(kErrorExitCode);
     }
     Dart_EnterScope();
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
     CHECK_RESULT(result);
 
     // Set up the library tag handler in such a manner that it will use the
     // URL mapping specified on the command line to load the libraries.
     result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler);
     CHECK_RESULT(result);
 
+    if (commandline_packages_file != NULL) {
+      AddDependency(commandline_packages_file);
+    }
+
     Dart_QualifiedFunctionName* entry_points =
         ParseEntryPointsManifestIfPresent();
 
     if (is_kernel_file) {
       Dart_Handle library = Dart_LoadKernel(kernel_program);
       if (Dart_IsError(library)) FATAL("Failed to load app from Kernel IR");
     } else {
       // Set up the library tag handler in such a manner that it will use the
       // URL mapping specified on the command line to load the libraries.
       result = Dart_SetLibraryTagHandler(CreateSnapshotLibraryTagHandler);
@@ skipping 10 matching lines @@
       CHECK_RESULT(library);
 
       ImportNativeEntryPointLibrariesIntoRoot(entry_points);
     }
 
     // Ensure that we mark all libraries as loaded.
     result = Dart_FinalizeLoading(false);
     CHECK_RESULT(result);
 
     switch (snapshot_kind) {
+      case kNone:
+        break;
       case kCore:
         CreateAndWriteCoreSnapshot();
         break;
       case kScript:
         CreateAndWriteScriptSnapshot();
         break;
       case kAppAOTBlobs:
       case kAppAOTAssembly:
         CreateAndWritePrecompiledSnapshot(entry_points);
         break;
       default:
         UNREACHABLE();
     }
 
+    CreateAndWriteDependenciesFile();
+
     Dart_ExitScope();
     Dart_ShutdownIsolate();
 
     CleanupEntryPointsCollection(entry_points);
 
     Dart_EnterIsolate(UriResolverIsolateScope::isolate);
     Dart_ShutdownIsolate();
   } else {
     SetupForGenericSnapshotCreation();
     CreateAndWriteCoreSnapshot();
@@ skipping 11 matching lines @@
   delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }