mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 09:58:32 +00:00
eabfad1158
running in the JIT VM TEST=new test added Bug:54528 Change-Id: Ifa0176ee453e5af4e45bb0b74cf9ac9ba23fb93e Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/346060 Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Siva Annamalai <asiva@google.com>
217 lines
7.6 KiB
C++
217 lines
7.6 KiB
C++
// 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.
|
|
|
|
#ifndef RUNTIME_BIN_DFE_H_
|
|
#define RUNTIME_BIN_DFE_H_
|
|
|
|
#include <memory>
|
|
|
|
#include "bin/thread.h"
|
|
#include "include/dart_api.h"
|
|
#include "include/dart_native_api.h"
|
|
#include "platform/assert.h"
|
|
#include "platform/globals.h"
|
|
#include "platform/hashmap.h"
|
|
#include "platform/utils.h"
|
|
|
|
namespace dart {
|
|
namespace bin {
|
|
|
|
class AppSnapshot; // Forward declaration.
|
|
|
|
class DFE {
|
|
public:
|
|
DFE();
|
|
~DFE();
|
|
|
|
// Call Init before Dart_Initialize to prevent races between the
|
|
// different isolates.
|
|
void Init();
|
|
|
|
char* frontend_filename() const { return frontend_filename_; }
|
|
|
|
void set_frontend_filename(const char* name) {
|
|
if (frontend_filename_ != nullptr) {
|
|
free(frontend_filename_);
|
|
}
|
|
frontend_filename_ = Utils::StrDup(name);
|
|
set_use_dfe();
|
|
}
|
|
void set_use_dfe(bool value = true) { use_dfe_ = value; }
|
|
bool UseDartFrontend() const { return use_dfe_; }
|
|
|
|
void set_use_incremental_compiler(bool value) {
|
|
use_incremental_compiler_ = value;
|
|
}
|
|
bool use_incremental_compiler() const { return use_incremental_compiler_; }
|
|
|
|
void set_verbosity(Dart_KernelCompilationVerbosityLevel verbosity) {
|
|
verbosity_ = verbosity;
|
|
}
|
|
Dart_KernelCompilationVerbosityLevel verbosity() const { return verbosity_; }
|
|
|
|
// Returns the platform binary file name if the path to
|
|
// kernel binaries was set using SetKernelBinaries.
|
|
const char* GetPlatformBinaryFilename();
|
|
|
|
// Set the kernel program for the main application if it was specified
|
|
// as a dill file.
|
|
void set_application_kernel_buffer(uint8_t* buffer, intptr_t size) {
|
|
application_kernel_buffer_ = buffer;
|
|
application_kernel_buffer_size_ = size;
|
|
}
|
|
void application_kernel_buffer(const uint8_t** buffer, intptr_t* size) const {
|
|
*buffer = application_kernel_buffer_;
|
|
*size = application_kernel_buffer_size_;
|
|
}
|
|
|
|
// Compiles specified script.
|
|
// Returns result from compiling the script.
|
|
//
|
|
// `snapshot` is used by the frontend to determine if compilation
|
|
// related information should be printed to console (e.g., null safety mode).
|
|
Dart_KernelCompilationResult CompileScript(const char* script_uri,
|
|
bool incremental,
|
|
const char* package_config,
|
|
bool for_snapshot,
|
|
bool embedd_sources);
|
|
|
|
// Compiles specified script and reads the resulting kernel file.
|
|
// If the compilation is successful, returns a valid in memory kernel
|
|
// representation of the script, nullptr otherwise
|
|
// 'error' and 'exit_code' have the error values in case of errors.
|
|
//
|
|
// `snapshot` is used by the frontend to determine if compilation
|
|
// related information should be printed to console (e.g., null safety mode).
|
|
void 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);
|
|
|
|
// Reads the script kernel file if specified 'script_uri' is a kernel file.
|
|
// Returns an in memory kernel representation of the specified script is a
|
|
// valid kernel file, sets 'kernel_buffer' to nullptr otherwise.
|
|
//
|
|
// If 'kernel_blob_ptr' is not nullptr, then this function can also
|
|
// read kernel blobs. In such case it sets 'kernel_blob_ptr'
|
|
// to a shared pointer which owns the kernel buffer.
|
|
// Otherwise, the caller is responsible for free()ing 'kernel_buffer'.
|
|
void ReadScript(const char* script_uri,
|
|
const AppSnapshot* app_snapshot,
|
|
uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size,
|
|
bool decode_uri = true,
|
|
std::shared_ptr<uint8_t>* kernel_blob_ptr = nullptr);
|
|
|
|
bool KernelServiceDillAvailable() const;
|
|
|
|
// Tries to read 'script_uri' as a Kernel IR file.
|
|
// Returns `true` if successful and sets 'kernel_buffer' and 'kernel_length'
|
|
// to be the kernel IR contents.
|
|
//
|
|
// If 'kernel_blob_ptr' is not nullptr, then this function can also
|
|
// read kernel blobs. In such case it sets 'kernel_blob_ptr'
|
|
// to a shared pointer which owns the kernel buffer.
|
|
// Otherwise, the caller is responsible for free()ing 'kernel_buffer'
|
|
// if `true` was returned.
|
|
bool TryReadKernelFile(const char* script_uri,
|
|
const AppSnapshot* app_snapshot,
|
|
uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size,
|
|
bool decode_uri = true,
|
|
std::shared_ptr<uint8_t>* kernel_blob_ptr = nullptr);
|
|
|
|
// We distinguish between "intent to use Dart frontend" vs "can actually
|
|
// use Dart frontend". The method UseDartFrontend tells us about the
|
|
// intent to use DFE. This method tells us if Dart frontend can actually
|
|
// be used.
|
|
bool CanUseDartFrontend() const;
|
|
|
|
void LoadPlatform(const uint8_t** kernel_buffer,
|
|
intptr_t* kernel_buffer_size);
|
|
void LoadKernelService(const uint8_t** kernel_service_buffer,
|
|
intptr_t* kernel_service_buffer_size);
|
|
|
|
// Registers given kernel blob and returns blob URI which
|
|
// can be used in TryReadKernelFile later to load the given kernel.
|
|
// Data from [kernel_buffer] is copied, it doesn't need to stay alive.
|
|
// Returns nullptr if failed to allocate memory.
|
|
const char* RegisterKernelBlob(const uint8_t* kernel_buffer,
|
|
intptr_t kernel_buffer_size);
|
|
|
|
// Looks for kernel blob using the given [uri].
|
|
// Returns non-null pointer to the kernel blob if successful and
|
|
// sets [kernel_length].
|
|
std::shared_ptr<uint8_t> TryFindKernelBlob(const char* uri,
|
|
intptr_t* kernel_length);
|
|
|
|
// Unregisters kernel blob with given URI.
|
|
void UnregisterKernelBlob(const char* uri);
|
|
|
|
private:
|
|
bool use_dfe_;
|
|
bool use_incremental_compiler_;
|
|
char* frontend_filename_;
|
|
Dart_KernelCompilationVerbosityLevel verbosity_ =
|
|
Dart_KernelCompilationVerbosityLevel_All;
|
|
|
|
// Kernel binary specified on the cmd line.
|
|
uint8_t* application_kernel_buffer_;
|
|
intptr_t application_kernel_buffer_size_;
|
|
|
|
// Registry of kernel blobs. Maps URI (char *) to KernelBlob.
|
|
SimpleHashMap kernel_blobs_;
|
|
intptr_t kernel_blob_counter_ = 0;
|
|
Mutex kernel_blobs_lock_;
|
|
|
|
void InitKernelServiceAndPlatformDills();
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(DFE);
|
|
};
|
|
|
|
class KernelBlob {
|
|
public:
|
|
// Takes ownership over [uri] and [buffer].
|
|
KernelBlob(char* uri, uint8_t* buffer, intptr_t size)
|
|
: uri_(uri, std::free), buffer_(buffer, std::free), size_(size) {}
|
|
|
|
std::shared_ptr<uint8_t> buffer() { return buffer_; }
|
|
intptr_t size() const { return size_; }
|
|
|
|
private:
|
|
Utils::CStringUniquePtr uri_;
|
|
std::shared_ptr<uint8_t> buffer_;
|
|
const intptr_t size_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(KernelBlob);
|
|
};
|
|
|
|
class PathSanitizer {
|
|
public:
|
|
explicit PathSanitizer(const char* path);
|
|
const char* sanitized_uri() const;
|
|
|
|
private:
|
|
#if defined(DART_HOST_OS_WINDOWS)
|
|
std::unique_ptr<char[]> sanitized_uri_;
|
|
#else
|
|
const char* sanitized_uri_;
|
|
#endif // defined(DART_HOST_OS_WINDOWS)
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(PathSanitizer);
|
|
};
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
extern DFE dfe;
|
|
#endif
|
|
|
|
} // namespace bin
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_BIN_DFE_H_
|