| // Copyright (c) 2017, 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. |
| |
| #include "bin/dfe.h" |
| |
| #include "bin/dartutils.h" |
| #include "bin/directory.h" |
| #include "bin/error_exit.h" |
| #include "bin/exe_utils.h" |
| #include "bin/file.h" |
| #include "bin/lockers.h" |
| #include "bin/platform.h" |
| #include "bin/snapshot_utils.h" |
| #include "bin/utils.h" |
| #include "include/dart_tools_api.h" |
| #include "platform/utils.h" |
| |
| extern "C" { |
| #if !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) |
| extern const uint8_t kKernelServiceDill[]; |
| extern intptr_t kKernelServiceDillSize; |
| extern const uint8_t kPlatformStrongDill[]; |
| extern intptr_t kPlatformStrongDillSize; |
| #else |
| const uint8_t* kKernelServiceDill = nullptr; |
| intptr_t kKernelServiceDillSize = 0; |
| const uint8_t* kPlatformStrongDill = nullptr; |
| intptr_t kPlatformStrongDillSize = 0; |
| #endif // !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) |
| } |
| |
| namespace dart { |
| namespace bin { |
| |
| // The run_vm_tests binary has the DART_PRECOMPILER set in order to allow unit |
| // tests to exercise JIT and AOT pipeline. |
| // |
| // Only on X64 do we have kernel-service.dart.snapshot available otherwise we |
| // need to fall back to the built-in one (if we have it). |
| #if defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) || \ |
| (defined(DART_PRECOMPILER) && defined(TARGET_ARCH_X64)) |
| const uint8_t* kernel_service_dill = nullptr; |
| const intptr_t kernel_service_dill_size = 0; |
| #else |
| const uint8_t* kernel_service_dill = kKernelServiceDill; |
| const intptr_t kernel_service_dill_size = kKernelServiceDillSize; |
| #endif |
| |
| #if defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) |
| const uint8_t* platform_strong_dill = nullptr; |
| const intptr_t platform_strong_dill_size = 0; |
| #else |
| const uint8_t* platform_strong_dill = kPlatformStrongDill; |
| const intptr_t platform_strong_dill_size = kPlatformStrongDillSize; |
| #endif |
| |
| #if !defined(DART_PRECOMPILED_RUNTIME) |
| DFE dfe; |
| #endif |
| |
| const char kKernelServiceSnapshot[] = "kernel-service.dart.snapshot"; |
| const char kSnapshotsDirectory[] = "snapshots"; |
| |
| DFE::DFE() |
| : use_dfe_(false), |
| use_incremental_compiler_(false), |
| frontend_filename_(nullptr), |
| application_kernel_buffer_(nullptr), |
| application_kernel_buffer_size_(0), |
| kernel_blobs_(&SimpleHashMap::SameStringValue, 4), |
| kernel_blobs_lock_() {} |
| |
| DFE::~DFE() { |
| if (frontend_filename_ != nullptr) { |
| free(frontend_filename_); |
| } |
| frontend_filename_ = nullptr; |
| |
| free(application_kernel_buffer_); |
| application_kernel_buffer_ = nullptr; |
| application_kernel_buffer_size_ = 0; |
| |
| kernel_blobs_.Clear( |
| [](void* value) { delete reinterpret_cast<KernelBlob*>(value); }); |
| } |
| |
| void DFE::Init() { |
| if (platform_strong_dill == nullptr) { |
| return; |
| } |
| |
| InitKernelServiceAndPlatformDills(); |
| Dart_SetDartLibrarySourcesKernel(platform_strong_dill, |
| platform_strong_dill_size); |
| } |
| |
| void DFE::InitKernelServiceAndPlatformDills() { |
| if (frontend_filename_ != nullptr) { |
| return; |
| } |
| |
| // |dir_prefix| includes the last path separator. |
| auto dir_prefix = EXEUtils::GetDirectoryPrefixFromResolvedExeName(); |
| |
| // Look for the frontend snapshot next to the executable. |
| frontend_filename_ = |
| Utils::SCreate("%s%s", dir_prefix.get(), kKernelServiceSnapshot); |
| if (File::Exists(nullptr, frontend_filename_)) { |
| return; |
| } |
| free(frontend_filename_); |
| frontend_filename_ = nullptr; |
| |
| // If the frontend snapshot is not found next to the executable, then look for |
| // it in the "snapshots" directory. |
| frontend_filename_ = |
| Utils::SCreate("%s%s%s%s", dir_prefix.get(), kSnapshotsDirectory, |
| File::PathSeparator(), kKernelServiceSnapshot); |
| if (File::Exists(nullptr, frontend_filename_)) { |
| return; |
| } |
| free(frontend_filename_); |
| frontend_filename_ = nullptr; |
| } |
| |
| bool DFE::KernelServiceDillAvailable() const { |
| return kernel_service_dill != nullptr; |
| } |
| |
| void DFE::LoadKernelService(const uint8_t** kernel_service_buffer, |
| intptr_t* kernel_service_buffer_size) { |
| *kernel_service_buffer = kernel_service_dill; |
| *kernel_service_buffer_size = kernel_service_dill_size; |
| } |
| |
| void DFE::LoadPlatform(const uint8_t** kernel_buffer, |
| intptr_t* kernel_buffer_size) { |
| *kernel_buffer = platform_strong_dill; |
| *kernel_buffer_size = platform_strong_dill_size; |
| } |
| |
| bool DFE::CanUseDartFrontend() const { |
| return (platform_strong_dill != nullptr) && |
| (KernelServiceDillAvailable() || (frontend_filename() != nullptr)); |
| } |
| |
| PathSanitizer::PathSanitizer(const char* path) { |
| #if defined(DART_HOST_OS_WINDOWS) |
| // For Windows we need to massage the paths a bit according to |
| // http://blogs.msdn.com/b/ie/archive/2006/12/06/file-uris-in-windows.aspx |
| // |
| // Convert |
| // C:\one\two\three |
| // to |
| // /C:/one/two/three |
| // |
| // (see builtin.dart#_sanitizeWindowsPath) |
| if (path == nullptr) { |
| return; |
| } |
| intptr_t len = strlen(path); |
| char* uri = reinterpret_cast<char*>(new char[len + 1 + 1]); |
| if (uri == nullptr) { |
| OUT_OF_MEMORY(); |
| } |
| char* s = uri; |
| if (len > 2 && path[1] == ':') { |
| *s++ = '/'; |
| } |
| for (const char* p = path; *p != '\0'; ++p, ++s) { |
| *s = *p == '\\' ? '/' : *p; |
| } |
| *s = '\0'; |
| sanitized_uri_ = std::unique_ptr<char[]>(uri); |
| #else |
| sanitized_uri_ = path; |
| #endif // defined(DART_HOST_OS_WINDOWS) |
| } |
| |
| const char* PathSanitizer::sanitized_uri() const { |
| #if defined(DART_HOST_OS_WINDOWS) |
| return sanitized_uri_.get(); |
| #else |
| return sanitized_uri_; |
| #endif // defined(DART_HOST_OS_WINDOWS) |
| } |
| |
| Dart_KernelCompilationResult DFE::CompileScript(const char* script_uri, |
| bool incremental, |
| const char* package_config, |
| bool for_snapshot, |
| bool embed_sources) { |
| // TODO(aam): When Frontend is ready, VM should be passing vm_outline.dill |
| // instead of vm_platform.dill to Frontend for compilation. |
| PathSanitizer path_sanitizer(script_uri); |
| const char* sanitized_uri = path_sanitizer.sanitized_uri(); |
| |
| return Dart_CompileToKernel( |
| sanitized_uri, platform_strong_dill, platform_strong_dill_size, |
| incremental, for_snapshot, embed_sources, package_config, verbosity()); |
| } |
| |
| void DFE::CompileAndReadScript(const char* script_uri, |
| uint8_t** kernel_buffer, |
| intptr_t* kernel_buffer_size, |
| char** error, |
| int* exit_code, |
| const char* package_config, |
| bool for_snapshot, |
| bool embed_sources) { |
| Dart_KernelCompilationResult result = |
| CompileScript(script_uri, use_incremental_compiler(), package_config, |
| for_snapshot, embed_sources); |
| switch (result.status) { |
| case Dart_KernelCompilationStatus_Ok: |
| *kernel_buffer = result.kernel; |
| *kernel_buffer_size = result.kernel_size; |
| *error = nullptr; |
| *exit_code = 0; |
| break; |
| case Dart_KernelCompilationStatus_Error: |
| free(result.kernel); |
| *error = result.error; // Copy error message. |
| *exit_code = kCompilationErrorExitCode; |
| break; |
| case Dart_KernelCompilationStatus_Crash: |
| free(result.kernel); |
| *error = result.error; // Copy error message. |
| *exit_code = kDartFrontendErrorExitCode; |
| break; |
| case Dart_KernelCompilationStatus_Unknown: |
| case Dart_KernelCompilationStatus_MsgFailed: |
| free(result.kernel); |
| *error = result.error; // Copy error message. |
| *exit_code = kErrorExitCode; |
| break; |
| } |
| } |
| |
| void DFE::ReadScript(const char* script_uri, |
| const AppSnapshot* app_snapshot, |
| uint8_t** kernel_buffer, |
| intptr_t* kernel_buffer_size, |
| bool decode_uri, |
| std::shared_ptr<uint8_t>* kernel_blob_ptr) { |
| int64_t start = Dart_TimelineGetMicros(); |
| if (!TryReadKernelFile(script_uri, app_snapshot, kernel_buffer, |
| kernel_buffer_size, decode_uri, kernel_blob_ptr)) { |
| return; |
| } |
| if (!Dart_IsKernel(*kernel_buffer, *kernel_buffer_size)) { |
| if (kernel_blob_ptr != nullptr && *kernel_blob_ptr) { |
| *kernel_blob_ptr = nullptr; |
| } else { |
| free(*kernel_buffer); |
| } |
| *kernel_buffer = nullptr; |
| *kernel_buffer_size = -1; |
| } |
| int64_t end = Dart_TimelineGetMicros(); |
| Dart_RecordTimelineEvent("DFE::ReadScript", start, end, /*flow_id_count=*/0, |
| nullptr, Dart_Timeline_Event_Duration, |
| /*argument_count=*/0, nullptr, nullptr); |
| } |
| |
| // Attempts to treat [buffer] as a in-memory kernel byte representation. |
| // If successful, returns [true] and places [buffer] into [kernel_ir], byte size |
| // into [kernel_ir_size]. |
| // If unsuccessful, returns [false], puts [nullptr] into [kernel_ir], -1 into |
| // [kernel_ir_size]. |
| static bool TryReadSimpleKernelBuffer(uint8_t* buffer, |
| uint8_t** p_kernel_ir, |
| intptr_t* p_kernel_ir_size) { |
| DartUtils::MagicNumber magic_number = |
| DartUtils::SniffForMagicNumber(buffer, *p_kernel_ir_size); |
| if (magic_number == DartUtils::kKernelMagicNumber) { |
| // Do not free buffer if this is a kernel file - kernel_file will be |
| // backed by the same memory as the buffer and caller will own it. |
| // Caller is responsible for freeing the buffer when this function |
| // returns true. |
| *p_kernel_ir = buffer; |
| return true; |
| } |
| free(buffer); |
| *p_kernel_ir = nullptr; |
| *p_kernel_ir_size = -1; |
| return false; |
| } |
| |
| /// Reads [script_uri] file, returns [true] if successful, [false] otherwise. |
| /// |
| /// If successful, newly allocated buffer with file contents is returned in |
| /// [buffer], file contents byte count - in [size]. |
| static bool TryReadFile(const char* script_uri, |
| uint8_t** buffer, |
| intptr_t* size, |
| bool decode_uri = true) { |
| void* script_file = decode_uri ? DartUtils::OpenFileUri(script_uri, false) |
| : DartUtils::OpenFile(script_uri, false); |
| if (script_file == nullptr) { |
| return false; |
| } |
| DartUtils::ReadFile(buffer, size, script_file); |
| DartUtils::CloseFile(script_file); |
| return *buffer != nullptr; |
| } |
| |
| class KernelIRNode { |
| public: |
| KernelIRNode(uint8_t* kernel_ir, intptr_t kernel_size) |
| : kernel_ir_(kernel_ir), kernel_size_(kernel_size) {} |
| |
| ~KernelIRNode() { free(kernel_ir_); } |
| |
| static void Add(KernelIRNode** p_head, |
| KernelIRNode** p_tail, |
| KernelIRNode* node) { |
| if (*p_head == nullptr) { |
| *p_head = node; |
| } else { |
| (*p_tail)->next_ = node; |
| } |
| *p_tail = node; |
| } |
| |
| static void Merge(KernelIRNode* head, uint8_t** p_bytes, intptr_t* p_size) { |
| intptr_t size = 0; |
| for (KernelIRNode* node = head; node != nullptr; node = node->next_) { |
| size = size + node->kernel_size_; |
| } |
| |
| *p_bytes = reinterpret_cast<uint8_t*>(malloc(size)); |
| uint8_t* p = *p_bytes; |
| KernelIRNode* node = head; |
| while (node != nullptr) { |
| memmove(p, node->kernel_ir_, node->kernel_size_); |
| p += node->kernel_size_; |
| KernelIRNode* next = node->next_; |
| node = next; |
| } |
| *p_size = size; |
| } |
| |
| static void Delete(KernelIRNode* head) { |
| KernelIRNode* node = head; |
| while (node != nullptr) { |
| KernelIRNode* next = node->next_; |
| delete (node); |
| node = next; |
| } |
| } |
| |
| private: |
| uint8_t* kernel_ir_; |
| intptr_t kernel_size_; |
| |
| KernelIRNode* next_ = nullptr; |
| |
| DISALLOW_COPY_AND_ASSIGN(KernelIRNode); |
| }; |
| |
| class StringPointer { |
| public: |
| explicit StringPointer(char* c_str) : c_str_(c_str) {} |
| ~StringPointer() { free(c_str_); } |
| |
| const char* c_str() { return c_str_; } |
| |
| private: |
| char* c_str_; |
| DISALLOW_COPY_AND_ASSIGN(StringPointer); |
| }; |
| |
| // Supports "kernel list" files as input. |
| // Those are text files that start with '#@dill' on new line, followed |
| // by absolute paths to kernel files or relative paths, that are relative |
| // to [script_uri] "kernel list" file. |
| // Below is an example of valid kernel list file: |
| // ``` |
| // #@dill |
| // /projects/mytest/build/bin/main.vm.dill |
| // /projects/mytest/build/packages/mytest/lib.vm.dill |
| // ``` |
| static bool TryReadKernelListBuffer(const char* script_uri, |
| uint8_t* buffer, |
| intptr_t buffer_size, |
| uint8_t** kernel_ir, |
| intptr_t* kernel_ir_size) { |
| const char* kernel_list_dirname = DartUtils::DirName(script_uri); |
| if (strcmp(kernel_list_dirname, script_uri) == 0) { |
| kernel_list_dirname = ""; |
| } |
| KernelIRNode* kernel_ir_head = nullptr; |
| KernelIRNode* kernel_ir_tail = nullptr; |
| // Add all kernels to the linked list |
| char* filename = |
| reinterpret_cast<char*>(buffer + kernel_list_magic_number.length); |
| intptr_t filename_size = buffer_size - kernel_list_magic_number.length; |
| char* tail = reinterpret_cast<char*>(memchr(filename, '\n', filename_size)); |
| while (tail != nullptr) { |
| *tail = '\0'; |
| intptr_t this_kernel_size; |
| uint8_t* this_buffer; |
| |
| StringPointer resolved_filename( |
| File::IsAbsolutePath(filename) |
| ? Utils::StrDup(filename) |
| : Utils::SCreate("%s%s", kernel_list_dirname, filename)); |
| if (!TryReadFile(resolved_filename.c_str(), &this_buffer, |
| &this_kernel_size)) { |
| return false; |
| } |
| |
| uint8_t* this_kernel_ir; |
| if (!TryReadSimpleKernelBuffer(this_buffer, &this_kernel_ir, |
| &this_kernel_size)) { |
| // Abandon read if any of the files in the list are invalid. |
| KernelIRNode::Delete(kernel_ir_head); |
| *kernel_ir = nullptr; |
| *kernel_ir_size = -1; |
| return false; |
| } |
| KernelIRNode::Add(&kernel_ir_head, &kernel_ir_tail, |
| new KernelIRNode(this_kernel_ir, this_kernel_size)); |
| filename_size -= tail + 1 - filename; |
| filename = tail + 1; |
| tail = reinterpret_cast<char*>(memchr(filename, '\n', filename_size)); |
| } |
| free(buffer); |
| |
| KernelIRNode::Merge(kernel_ir_head, kernel_ir, kernel_ir_size); |
| KernelIRNode::Delete(kernel_ir_head); |
| return true; |
| } |
| |
| bool DFE::TryReadKernelFile(const char* script_uri, |
| const AppSnapshot* app_snapshot, |
| uint8_t** kernel_ir, |
| intptr_t* kernel_ir_size, |
| bool decode_uri, |
| std::shared_ptr<uint8_t>* kernel_blob_ptr) { |
| *kernel_ir = nullptr; |
| *kernel_ir_size = -1; |
| |
| if (decode_uri && kernel_blob_ptr != nullptr) { |
| *kernel_blob_ptr = TryFindKernelBlob(script_uri, kernel_ir_size); |
| if (*kernel_blob_ptr) { |
| *kernel_ir = kernel_blob_ptr->get(); |
| ASSERT(DartUtils::SniffForMagicNumber(*kernel_ir, *kernel_ir_size) == |
| DartUtils::kKernelMagicNumber); |
| return true; |
| } |
| } |
| if (app_snapshot == nullptr || app_snapshot->IsKernel() || |
| app_snapshot->IsKernelList()) { |
| uint8_t* buffer; |
| if (!TryReadFile(script_uri, &buffer, kernel_ir_size, decode_uri)) { |
| return false; |
| } |
| auto magic_number = DartUtils::kUnknownMagicNumber; |
| if (app_snapshot == nullptr) { |
| magic_number = DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size); |
| } else if (app_snapshot->IsKernel()) { |
| magic_number = DartUtils::kKernelMagicNumber; |
| ASSERT(DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) == |
| DartUtils::kKernelMagicNumber); |
| } else { |
| magic_number = DartUtils::kKernelListMagicNumber; |
| ASSERT(DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) == |
| DartUtils::kKernelListMagicNumber); |
| } |
| if (magic_number == DartUtils::kKernelListMagicNumber) { |
| return TryReadKernelListBuffer(script_uri, buffer, *kernel_ir_size, |
| kernel_ir, kernel_ir_size); |
| } |
| return TryReadSimpleKernelBuffer(buffer, kernel_ir, kernel_ir_size); |
| } |
| return false; |
| } |
| |
| const char* DFE::RegisterKernelBlob(const uint8_t* kernel_buffer, |
| intptr_t kernel_buffer_size) { |
| ASSERT(DartUtils::SniffForMagicNumber(kernel_buffer, kernel_buffer_size) == |
| DartUtils::kKernelMagicNumber); |
| uint8_t* buffer_copy = reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size)); |
| if (buffer_copy == nullptr) { |
| return nullptr; |
| } |
| memmove(buffer_copy, kernel_buffer, kernel_buffer_size); |
| |
| MutexLocker ml(&kernel_blobs_lock_); |
| ++kernel_blob_counter_; |
| char* uri = |
| Utils::SCreate("dart-kernel-blob://blob%" Pd, kernel_blob_counter_); |
| KernelBlob* blob = new KernelBlob(uri, buffer_copy, kernel_buffer_size); |
| |
| const uint32_t hash = SimpleHashMap::StringHash(uri); |
| SimpleHashMap::Entry* entry = |
| kernel_blobs_.Lookup(uri, hash, /*insert=*/true); |
| ASSERT(entry != nullptr); |
| ASSERT(entry->value == nullptr); |
| entry->value = blob; |
| |
| return uri; |
| } |
| |
| std::shared_ptr<uint8_t> DFE::TryFindKernelBlob(const char* uri, |
| intptr_t* kernel_length) { |
| *kernel_length = -1; |
| |
| MutexLocker ml(&kernel_blobs_lock_); |
| if (kernel_blob_counter_ == 0) { |
| return nullptr; |
| } |
| |
| // This const_cast is safe as this 'key' is only used to find entry, not add. |
| void* key = const_cast<char*>(uri); |
| const uint32_t hash = SimpleHashMap::StringHash(uri); |
| SimpleHashMap::Entry* entry = |
| kernel_blobs_.Lookup(key, hash, /*insert=*/false); |
| if (entry == nullptr) { |
| return nullptr; |
| } |
| |
| KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value); |
| *kernel_length = blob->size(); |
| return blob->buffer(); |
| } |
| |
| void DFE::UnregisterKernelBlob(const char* uri) { |
| MutexLocker ml(&kernel_blobs_lock_); |
| |
| // This const_cast is safe as this 'key' is only used to find entry, not add. |
| void* key = const_cast<char*>(uri); |
| const uint32_t hash = SimpleHashMap::StringHash(uri); |
| SimpleHashMap::Entry* entry = |
| kernel_blobs_.Lookup(key, hash, /*insert=*/false); |
| if (entry == nullptr) { |
| return; |
| } |
| |
| KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value); |
| entry->value = nullptr; |
| kernel_blobs_.Remove(key, hash); |
| delete blob; |
| } |
| |
| } // namespace bin |
| } // namespace dart |