dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Revert "[vm] Remove Dart_ReadKernelBinary."

Browse Source 
This reverts commit 2998c32951.

Reason for revert: Failures with kernel + simulators

Original change's description:
> [vm] Remove Dart_ReadKernelBinary.
> 
>  - Fix const-ness of Dart_FileReadCallback and callers.
>  - Fix leak on read error in DartUtils::FileRead.
> 
> This is progress towards sharing kernel memory on Fuchsia.
> 
> Bug: https://github.com/dart-lang/sdk/issues/32618
> Change-Id: I47f8b224905d6a105a5ca0ab2ee4ab6a42b5e342
> Reviewed-on: https://dart-review.googlesource.com/47102
> Commit-Queue: Ryan Macnak <rmacnak@google.com>
> Reviewed-by: Siva Annamalai <asiva@google.com>

TBR=aam@google.com,rmacnak@google.com,asiva@google.com

Change-Id: Ibb636b817de1629a062fe0a6ef9462a2fef669ef
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: https://github.com/dart-lang/sdk/issues/32618
Reviewed-on: https://dart-review.googlesource.com/54560
Reviewed-by: Ryan Macnak <rmacnak@google.com>
Commit-Queue: Ryan Macnak <rmacnak@google.com>
This commit is contained in:
Ryan Macnak
2018-05-10 01:36:39 +00:00
committed by commit-bot@chromium.org
parent c25a9fd46b
commit 407872b9e5
28 changed files with 374 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/bin/dartutils.cc
+11 -13
View File
@@ -213,7 +213,7 @@ void* DartUtils::OpenFileUri(const char* uri, bool write) {
return reinterpret_cast<void*>(file);
}
void DartUtils::ReadFile(uint8_t** data, intptr_t* len, void* stream) {
void DartUtils::ReadFile(const uint8_t** data, intptr_t* len, void* stream) {
ASSERT(data != NULL);
ASSERT(len != NULL);
ASSERT(stream != NULL);
@@ -225,16 +225,14 @@ void DartUtils::ReadFile(uint8_t** data, intptr_t* len, void* stream) {
return;
}
*len = static_cast<intptr_t>(file_len);
*data = reinterpret_cast<uint8_t*>(malloc(*len));
if (*data == NULL) {
OUT_OF_MEMORY();
}
if (!file_stream->ReadFully(*data, *len)) {
free(*data);
uint8_t* text_buffer = reinterpret_cast<uint8_t*>(malloc(*len));
ASSERT(text_buffer != NULL);
if (!file_stream->ReadFully(text_buffer, *len)) {
*data = NULL;
*len = -1; // Indicates read was not successful.
return;
}
*data = text_buffer;
}
void DartUtils::WriteFile(const void* buffer,
@@ -272,16 +270,16 @@ static Dart_Handle SingleArgDart_Invoke(Dart_Handle lib,
snprintf(msg, len + 1, format, __VA_ARGS__); \
*error_msg = msg
static uint8_t* ReadFileFully(const char* filename,
intptr_t* file_len,
const char** error_msg) {
static const uint8_t* ReadFileFully(const char* filename,
intptr_t* file_len,
const char** error_msg) {
*file_len = -1;
void* stream = DartUtils::OpenFile(filename, false);
if (stream == NULL) {
SET_ERROR_MSG(error_msg, "Unable to open file: %s", filename);
return NULL;
}
uint8_t* text_buffer = NULL;
const uint8_t* text_buffer = NULL;
DartUtils::ReadFile(&text_buffer, file_len, stream);
if (text_buffer == NULL || *file_len == -1) {
*error_msg = "Unable to read file contents";
@@ -294,12 +292,12 @@ static uint8_t* ReadFileFully(const char* filename,
Dart_Handle DartUtils::ReadStringFromFile(const char* filename) {
const char* error_msg = NULL;
intptr_t len;
uint8_t* text_buffer = ReadFileFully(filename, &len, &error_msg);
const uint8_t* text_buffer = ReadFileFully(filename, &len, &error_msg);
if (text_buffer == NULL) {
return Dart_NewApiError(error_msg);
}
Dart_Handle str = Dart_NewStringFromUTF8(text_buffer, len);
free(text_buffer);
free(const_cast<uint8_t*>(text_buffer));
return str;
}
runtime/bin/dartutils.h
+1 -1
View File
@@ -122,7 +122,7 @@ class DartUtils {
static void* MapExecutable(const char* name, intptr_t* file_len);
static void* OpenFile(const char* name, bool write);
static void* OpenFileUri(const char* uri, bool write);
static void ReadFile(uint8_t** data, intptr_t* file_len, void* stream);
static void ReadFile(const uint8_t** data, intptr_t* file_len, void* stream);
static void WriteFile(const void* buffer, intptr_t num_bytes, void* stream);
static void CloseFile(void* stream);
static bool EntropySource(uint8_t* buffer, intptr_t length);
runtime/bin/dfe.cc
+70 -47
View File
@@ -3,16 +3,14 @@
// 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/file.h"
#include "bin/platform.h"
#include "bin/utils.h"
#include "include/dart_tools_api.h"
#include "platform/utils.h"
#include "vm/os.h"
#include "vm/kernel.h"
extern "C" {
#if !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM)
@@ -77,11 +75,15 @@ static char* GetDirectoryPrefixFromExeName() {
return Utils::StrNDup(name, i + 1);
}
static void NoopRelease(uint8_t* buffer) {}
DFE::DFE()
: use_dfe_(false),
frontend_filename_(NULL),
application_kernel_buffer_(NULL),
application_kernel_buffer_size_(0) {}
kernel_service_program_(NULL),
platform_program_(NULL),
platform_strong_program_(NULL),
application_kernel_binary_(NULL) {}
DFE::~DFE() {
if (frontend_filename_ != NULL) {
@@ -89,15 +91,38 @@ DFE::~DFE() {
}
frontend_filename_ = NULL;
free(application_kernel_buffer_);
application_kernel_buffer_ = NULL;
application_kernel_buffer_size_ = 0;
// Do NOT delete kernel_service_program_ in the destructor.
// It is always a full a dill file, hence it is used as
// argument to Dart_CreateIsolateFromKernel as well as loaded
// as the kernel program for the isolate. Hence, deleting here
// would lead to double deletion.
delete reinterpret_cast<kernel::Program*>(platform_program_);
platform_program_ = NULL;
delete reinterpret_cast<kernel::Program*>(platform_strong_program_);
platform_strong_program_ = NULL;
delete reinterpret_cast<kernel::Program*>(application_kernel_binary_);
application_kernel_binary_ = NULL;
}
void DFE::Init() {
if (platform_dill == NULL) {
return;
}
// platform_dill is not NULL implies that platform_strong_dill is also
// not NULL.
if (platform_program_ == NULL) {
ASSERT(Dart_IsKernel(platform_dill, platform_dill_size));
platform_program_ =
Dart_ReadKernelBinary(platform_dill, platform_dill_size, NoopRelease);
}
if (platform_strong_program_ == NULL) {
ASSERT(Dart_IsKernel(platform_strong_dill, platform_strong_dill_size));
platform_strong_program_ = Dart_ReadKernelBinary(
platform_strong_dill, platform_strong_dill_size, NoopRelease);
}
if (frontend_filename_ == NULL) {
// Look for the frontend snapshot next to the executable.
@@ -128,29 +153,34 @@ bool DFE::KernelServiceDillAvailable() {
return kernel_service_dill != NULL;
}
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::LoadKernelServiceProgram() {
if (kernel_service_dill == NULL) {
return NULL;
}
if (kernel_service_program_ == NULL) {
kernel_service_program_ = Dart_ReadKernelBinary(
kernel_service_dill, kernel_service_dill_size, NoopRelease);
}
return kernel_service_program_;
}
void DFE::LoadPlatform(const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
bool strong) {
void* DFE::platform_program(bool strong) const {
if (strong) {
*kernel_buffer = platform_strong_dill;
*kernel_buffer_size = platform_strong_dill_size;
return platform_strong_program_;
} else {
*kernel_buffer = platform_dill;
*kernel_buffer_size = platform_dill_size;
return platform_program_;
}
}
bool DFE::CanUseDartFrontend() const {
return (platform_dill != NULL) &&
return (platform_program() != NULL) &&
(KernelServiceDillAvailable() || (frontend_filename() != NULL));
}
static void ReleaseFetchedBytes(uint8_t* buffer) {
free(buffer);
}
class WindowsPathSanitizer {
public:
explicit WindowsPathSanitizer(const char* path) {
@@ -209,22 +239,17 @@ Dart_KernelCompilationResult DFE::CompileScript(const char* script_uri,
package_config);
}
void DFE::CompileAndReadScript(const char* script_uri,
uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
char** error,
int* exit_code,
bool strong,
const char* package_config) {
void* DFE::CompileAndReadScript(const char* script_uri,
char** error,
int* exit_code,
bool strong,
const char* package_config) {
Dart_KernelCompilationResult result =
CompileScript(script_uri, strong, true, package_config);
switch (result.status) {
case Dart_KernelCompilationStatus_Ok:
*kernel_buffer = result.kernel;
*kernel_buffer_size = result.kernel_size;
*error = NULL;
*exit_code = 0;
break;
return Dart_ReadKernelBinary(result.kernel, result.kernel_size,
ReleaseFetchedBytes);
case Dart_KernelCompilationStatus_Error:
*error = result.error; // Copy error message.
*exit_code = kCompilationErrorExitCode;
@@ -238,27 +263,25 @@ void DFE::CompileAndReadScript(const char* script_uri,
*exit_code = kErrorExitCode;
break;
}
return NULL;
}
void DFE::ReadScript(const char* script_uri,
uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size) const {
void* DFE::ReadScript(const char* script_uri) const {
int64_t start = Dart_TimelineGetMicros();
if (!TryReadKernelFile(script_uri, kernel_buffer, kernel_buffer_size)) {
return;
}
if (!Dart_IsKernel(*kernel_buffer, *kernel_buffer_size)) {
free(*kernel_buffer);
*kernel_buffer = NULL;
*kernel_buffer_size = -1;
}
const uint8_t* buffer = NULL;
intptr_t buffer_length = -1;
bool result = TryReadKernelFile(script_uri, &buffer, &buffer_length);
void* read_binary =
result ? Dart_ReadKernelBinary(buffer, buffer_length, ReleaseFetchedBytes)
: NULL;
int64_t end = Dart_TimelineGetMicros();
Dart_TimelineEvent("DFE::ReadScript", start, end,
Dart_Timeline_Event_Duration, 0, NULL, NULL);
return read_binary;
}
bool DFE::TryReadKernelFile(const char* script_uri,
uint8_t** kernel_ir,
const uint8_t** kernel_ir,
intptr_t* kernel_ir_size) {
*kernel_ir = NULL;
*kernel_ir_size = -1;
@@ -266,7 +289,7 @@ bool DFE::TryReadKernelFile(const char* script_uri,
if (script_file == NULL) {
return false;
}
uint8_t* buffer = NULL;
const uint8_t* buffer = NULL;
DartUtils::ReadFile(&buffer, kernel_ir_size, script_file);
DartUtils::CloseFile(script_file);
if (*kernel_ir_size == 0 || buffer == NULL) {
@@ -274,7 +297,7 @@ bool DFE::TryReadKernelFile(const char* script_uri,
}
if (DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) !=
DartUtils::kKernelMagicNumber) {
free(buffer);
free(const_cast<uint8_t*>(buffer));
*kernel_ir = NULL;
*kernel_ir_size = -1;
return false;
runtime/bin/dfe.h
+19 -26
View File
@@ -40,14 +40,10 @@ class DFE {
// 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_;
void set_application_kernel_binary(void* application_kernel_binary) {
application_kernel_binary_ = application_kernel_binary;
}
void* application_kernel_binary() const { return application_kernel_binary_; }
// Compiles specified script.
// Returns result from compiling the script.
@@ -60,20 +56,16 @@ class DFE {
// If the compilation is successful, returns a valid in memory kernel
// representation of the script, NULL otherwise
// 'error' and 'exit_code' have the error values in case of errors.
void CompileAndReadScript(const char* script_uri,
uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
char** error,
int* exit_code,
bool strong,
const char* package_config);
void* CompileAndReadScript(const char* script_uri,
char** error,
int* exit_code,
bool strong,
const char* package_config);
// 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, false otherwise.
void ReadScript(const char* script_uri,
uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size) const;
void* ReadScript(const char* script_uri) const;
static bool KernelServiceDillAvailable();
@@ -83,8 +75,8 @@ class DFE {
// The caller is responsible for free()ing [kernel_file] if `true`
// was returned.
static bool TryReadKernelFile(const char* script_uri,
uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size);
const uint8_t** kernel_ir,
intptr_t* kernel_ir_size);
// We distinguish between "intent to use Dart frontend" vs "can actually
// use Dart frontend". The method UseDartFrontend tells us about the
@@ -92,19 +84,20 @@ class DFE {
// be used.
bool CanUseDartFrontend() const;
void LoadPlatform(const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
bool strong = false);
void LoadKernelService(const uint8_t** kernel_service_buffer,
intptr_t* kernel_service_buffer_size);
void* platform_program(bool strong = false) const;
void* LoadKernelServiceProgram();
private:
bool use_dfe_;
char* frontend_filename_;
void* kernel_service_program_;
void* platform_program_;
void* platform_strong_program_;
// Kernel binary specified on the cmd line.
uint8_t* application_kernel_buffer_;
intptr_t application_kernel_buffer_size_;
void* application_kernel_binary_;
DISALLOW_COPY_AND_ASSIGN(DFE);
};
runtime/bin/gen_snapshot.cc
+13 -13
View File
@@ -1393,8 +1393,7 @@ static Dart_Isolate CreateServiceIsolate(const char* script_uri,
return isolate;
}
static int GenerateSnapshotFromKernel(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
static int GenerateSnapshotFromKernelProgram(void* kernel_program) {
ASSERT(SnapshotKindAllowedFromKernel());
char* error = NULL;
@@ -1418,8 +1417,7 @@ static int GenerateSnapshotFromKernel(const uint8_t* kernel_buffer,
// in the main isolate as well.
isolate_flags.load_vmservice_library = true;
Dart_Isolate isolate = Dart_CreateIsolateFromKernel(
NULL, NULL, kernel_buffer, kernel_buffer_size, &isolate_flags,
isolate_data, &error);
NULL, NULL, kernel_program, &isolate_flags, isolate_data, &error);
if (isolate == NULL) {
delete isolate_data;
Log::PrintErr("%s\n", error);
@@ -1441,8 +1439,11 @@ static int GenerateSnapshotFromKernel(const uint8_t* kernel_buffer,
//
// If the input dill file does not have a root library, then
// Dart_LoadScript will error.
Dart_Handle dummy_uri =
DartUtils::NewString("____dummy_gen_snapshot_root_library_uri____");
Dart_Handle library =
Dart_LoadScriptFromKernel(kernel_buffer, kernel_buffer_size);
Dart_LoadScript(dummy_uri, Dart_Null(),
reinterpret_cast<Dart_Handle>(kernel_program), 0, 0);
if (Dart_IsError(library)) {
Log::PrintErr("Unable to load root library from the input dill file.\n");
return kErrorExitCode;
@@ -1487,12 +1488,11 @@ int main(int argc, char** argv) {
}
// Sniff the script to check if it is actually a dill file.
uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = NULL;
void* kernel_program = NULL;
if (app_script_name != NULL) {
dfe.ReadScript(app_script_name, &kernel_buffer, &kernel_buffer_size);
kernel_program = dfe.ReadScript(app_script_name);
}
if (kernel_buffer != NULL && !SnapshotKindAllowedFromKernel()) {
if (kernel_program != NULL && !SnapshotKindAllowedFromKernel()) {
// TODO(sivachandra): Add check for the kernel program format (incremental
// vs batch).
Log::PrintErr(
@@ -1544,7 +1544,7 @@ int main(int argc, char** argv) {
Dart_InitializeParams init_params;
memset(&init_params, 0, sizeof(init_params));
init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
if (app_script_name != NULL && kernel_buffer == NULL) {
if (app_script_name != NULL && kernel_program == NULL) {
// We need the service isolate to load script files.
// When generating snapshots from a kernel program, we do not need to load
// any script files.
@@ -1590,8 +1590,8 @@ int main(int argc, char** argv) {
return kErrorExitCode;
}
if (kernel_buffer != NULL) {
return GenerateSnapshotFromKernel(kernel_buffer, kernel_buffer_size);
if (kernel_program != NULL) {
return GenerateSnapshotFromKernelProgram(kernel_program);
}
Dart_IsolateFlags flags;
@@ -1691,7 +1691,7 @@ int main(int argc, char** argv) {
AddDependency(commandline_packages_file);
}
ASSERT(kernel_buffer == NULL);
ASSERT(kernel_program == NULL);
// Load any libraries named in the entry points. Do this before loading the
// user's script to ensure conditional imports see the embedder-specific
runtime/bin/isolate_data.cc
+7 -8
View File
@@ -5,6 +5,8 @@
#include "bin/isolate_data.h"
#include "bin/snapshot_utils.h"
#include "vm/kernel.h"
namespace dart {
namespace bin {
@@ -15,13 +17,12 @@ IsolateData::IsolateData(const char* url,
: script_url((url != NULL) ? strdup(url) : NULL),
package_root(NULL),
packages_file(NULL),
kernel_program(NULL),
builtin_lib_(NULL),
loader_(NULL),
app_snapshot_(app_snapshot),
dependencies_(NULL),
kernel_buffer_(NULL),
kernel_buffer_size_(0),
owns_kernel_buffer_(false) {
create_isolate_from_kernel_(false) {
if (package_root != NULL) {
ASSERT(packages_file == NULL);
this->package_root = strdup(package_root);
@@ -44,12 +45,10 @@ IsolateData::~IsolateData() {
package_root = NULL;
free(packages_file);
packages_file = NULL;
if (owns_kernel_buffer_) {
ASSERT(kernel_buffer_ != NULL);
free(kernel_buffer_);
if (kernel_program != NULL) {
delete reinterpret_cast<kernel::Program*>(kernel_program);
kernel_program = NULL;
}
kernel_buffer_ = NULL;
kernel_buffer_size_ = 0;
delete app_snapshot_;
app_snapshot_ = NULL;
}
runtime/bin/isolate_data.h
+9 -12
View File
@@ -51,15 +51,7 @@ class IsolateData {
char* script_url;
char* package_root;
char* packages_file;
const uint8_t* kernel_buffer() const { return kernel_buffer_; }
intptr_t kernel_buffer_size() const { return kernel_buffer_size_; }
void set_kernel_buffer(uint8_t* buffer, intptr_t size, bool take_ownership) {
ASSERT(kernel_buffer_ == NULL);
kernel_buffer_ = buffer;
kernel_buffer_size_ = size;
owns_kernel_buffer_ = take_ownership;
}
void* kernel_program;
void UpdatePackagesFile(const char* packages_file_) {
if (packages_file != NULL) {
@@ -86,14 +78,19 @@ class IsolateData {
void OnIsolateShutdown();
void set_create_isolate_from_kernel(bool value) {
create_isolate_from_kernel_ = value;
}
bool create_isolate_from_kernel() const {
return create_isolate_from_kernel_;
}
private:
Dart_Handle builtin_lib_;
Loader* loader_;
AppSnapshot* app_snapshot_;
MallocGrowableArray<char*>* dependencies_;
uint8_t* kernel_buffer_;
intptr_t kernel_buffer_size_;
bool owns_kernel_buffer_;
bool create_isolate_from_kernel_;
DISALLOW_COPY_AND_ASSIGN(IsolateData);
};
runtime/bin/loader.cc
+17 -16
View File
@@ -336,6 +336,10 @@ class ScopedDecompress : public ValueObject {
uint8_t* decompressed_;
};
static void ReleaseFetchedBytes(uint8_t* buffer) {
free(buffer);
}
bool Loader::ProcessResultLocked(Loader* loader, Loader::IOResult* result) {
// We have to copy everything we care about out of |result| because after
// dropping the lock below |result| may no longer valid.
@@ -453,7 +457,10 @@ bool Loader::ProcessResultLocked(Loader* loader, Loader::IOResult* result) {
// isolates. We currently do not have support for neither
// `Isolate.spawn()` nor `Isolate.spawnUri()` with kernel-based
// frontend.
dart_result = Dart_LoadScriptFromKernel(payload, payload_length);
Dart_Handle kernel_binary =
reinterpret_cast<Dart_Handle>(Dart_ReadKernelBinary(
payload, payload_length, ReleaseFetchedBytes));
dart_result = Dart_LoadScript(uri, resolved_uri, kernel_binary, 0, 0);
} else {
dart_result = Dart_LoadScript(uri, resolved_uri, source, 0, 0);
}
@@ -639,12 +646,6 @@ Dart_Handle Loader::DartColonLibraryTagHandler(Dart_LibraryTag tag,
return Dart_Null();
}
#else
static void MallocFinalizer(void* isolate_callback_data,
Dart_WeakPersistentHandle handle,
void* peer) {
free(peer);
}
Dart_Handle Loader::LibraryTagHandler(Dart_LibraryTag tag,
Dart_Handle library,
Dart_Handle url) {
@@ -662,17 +663,17 @@ Dart_Handle Loader::LibraryTagHandler(Dart_LibraryTag tag,
}
Dart_Isolate current = Dart_CurrentIsolate();
if (tag == Dart_kKernelTag) {
uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
if (!DFE::TryReadKernelFile(url_string, &kernel_buffer,
&kernel_buffer_size)) {
const uint8_t* kernel_ir = NULL;
intptr_t kernel_ir_size = 0;
// Check to see if url_string points to a valid dill file. If so, return the
// loaded kernel::Program.
if (!DFE::TryReadKernelFile(url_string, &kernel_ir, &kernel_ir_size)) {
return DartUtils::NewError("'%s' is not a kernel file", url_string);
}
result = Dart_NewExternalTypedData(Dart_TypedData_kUint8, kernel_buffer,
kernel_buffer_size);
Dart_NewWeakPersistentHandle(result, kernel_buffer, kernel_buffer_size,
MallocFinalizer);
return result;
void* kernel_program =
Dart_ReadKernelBinary(kernel_ir, kernel_ir_size, ReleaseFetchedBytes);
return Dart_NewExternalTypedData(Dart_TypedData_kUint64, kernel_program, 1);
}
if (tag == Dart_kImportResolvedExtensionTag) {
if (strncmp(url_string, "file://", 7)) {
runtime/bin/main.cc
+38 -76
View File
@@ -224,12 +224,9 @@ static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
char** error,
int* exit_code) {
Dart_EnterScope();
#if !defined(DART_PRECOMPILED_RUNTIME)
IsolateData* isolate_data =
reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
const uint8_t* kernel_buffer = isolate_data->kernel_buffer();
intptr_t kernel_buffer_size = isolate_data->kernel_buffer_size();
#endif
void* kernel_program = isolate_data->kernel_program;
// Set up the library tag handler for this isolate.
Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
@@ -261,7 +258,7 @@ static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
#if !defined(DART_PRECOMPILED_RUNTIME)
if (Options::preview_dart_2() && !isolate_run_app_snapshot &&
kernel_buffer == NULL && !Dart_IsKernelIsolate(isolate)) {
kernel_program == NULL && !Dart_IsKernelIsolate(isolate)) {
if (!dfe.CanUseDartFrontend()) {
const char* format = "Dart frontend unavailable to compile script %s.";
intptr_t len = snprintf(NULL, 0, format, script_uri) + 1;
@@ -273,28 +270,24 @@ static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
Dart_ShutdownIsolate();
return NULL;
}
uint8_t* application_kernel_buffer = NULL;
intptr_t application_kernel_buffer_size = 0;
dfe.CompileAndReadScript(script_uri, &application_kernel_buffer,
&application_kernel_buffer_size, error, exit_code,
flags->strong, resolved_packages_config);
if (application_kernel_buffer == NULL) {
kernel_program = dfe.CompileAndReadScript(
script_uri, error, exit_code, flags->strong, resolved_packages_config);
if (kernel_program == NULL) {
Dart_ExitScope();
Dart_ShutdownIsolate();
return NULL;
}
isolate_data->set_kernel_buffer(application_kernel_buffer,
application_kernel_buffer_size,
true /*take ownership*/);
kernel_buffer = application_kernel_buffer;
kernel_buffer_size = application_kernel_buffer_size;
isolate_data->kernel_program = kernel_program;
}
if (kernel_buffer != NULL) {
if (kernel_program != NULL) {
Dart_Handle uri = Dart_NewStringFromCString(script_uri);
CHECK_RESULT(uri);
Dart_Handle resolved_script_uri = DartUtils::ResolveScript(uri);
CHECK_RESULT(resolved_script_uri);
result = Dart_LoadScriptFromKernel(kernel_buffer, kernel_buffer_size);
result =
Dart_LoadScript(uri, resolved_script_uri,
reinterpret_cast<Dart_Handle>(kernel_program), 0, 0);
isolate_data->kernel_program = NULL; // Dart_LoadScript takes ownership.
CHECK_RESULT(result);
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
@@ -329,12 +322,11 @@ static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
} else {
#if !defined(DART_PRECOMPILED_RUNTIME)
// Load the specified application script into the newly created isolate.
Dart_Handle uri =
DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri));
CHECK_RESULT(uri);
if (kernel_buffer == NULL) {
if (kernel_program == NULL) {
result = Loader::LibraryTagHandler(Dart_kScriptTag, Dart_Null(), uri);
CHECK_RESULT(result);
} else {
@@ -352,9 +344,6 @@ static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
result = DartUtils::SetupIOLibrary(Options::namespc(), script_uri,
Options::exit_disabled());
CHECK_RESULT(result);
#else
UNREACHABLE();
#endif // !defined(DART_PRECOMPILED_RUNTIME)
}
// Make the isolate runnable so that it is ready to handle messages.
@@ -413,18 +402,13 @@ static Dart_Isolate CreateAndSetupKernelIsolate(const char* script_uri,
isolate_snapshot_instructions, app_isolate_shared_data,
app_isolate_shared_instructions, flags, isolate_data, error);
} else {
const uint8_t* kernel_service_buffer = NULL;
intptr_t kernel_service_buffer_size = 0;
dfe.LoadKernelService(&kernel_service_buffer, &kernel_service_buffer_size);
ASSERT(kernel_service_buffer != NULL);
void* kernel_service_program = dfe.LoadKernelServiceProgram();
ASSERT(kernel_service_program != NULL);
IsolateData* isolate_data =
new IsolateData(uri, package_root, packages_config, NULL);
isolate_data->set_kernel_buffer(const_cast<uint8_t*>(kernel_service_buffer),
kernel_service_buffer_size,
false /* take_ownership */);
isolate = Dart_CreateIsolateFromKernel(uri, main, kernel_service_buffer,
kernel_service_buffer_size, flags,
isolate_data, error);
isolate_data->kernel_program = kernel_service_program;
isolate = Dart_CreateIsolateFromKernel(uri, main, kernel_service_program,
flags, isolate_data, error);
}
if (isolate == NULL) {
@@ -482,20 +466,15 @@ static Dart_Isolate CreateAndSetupServiceIsolate(const char* script_uri,
if (Options::preview_dart_2()) {
// If there is intention to use DFE, then we create the isolate
// from kernel only if we can.
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
dfe.LoadPlatform(&kernel_buffer, &kernel_buffer_size, flags->strong);
if (kernel_buffer == NULL) {
dfe.application_kernel_buffer(&kernel_buffer, &kernel_buffer_size);
}
void* platform_program = dfe.platform_program(flags->strong) != NULL
? dfe.platform_program(flags->strong)
: dfe.application_kernel_binary();
// TODO(sivachandra): When the platform program is unavailable, check if
// application kernel binary is self contained or an incremental binary.
// Isolate should be created only if it is a self contained kernel binary.
if (kernel_buffer != NULL) {
isolate = Dart_CreateIsolateFromKernel(script_uri, NULL, kernel_buffer,
kernel_buffer_size, flags,
isolate_data, error);
if (platform_program != NULL) {
isolate = Dart_CreateIsolateFromKernel(script_uri, NULL, platform_program,
flags, isolate_data, error);
} else {
*error =
strdup("Platform kernel not available to create service isolate.");
@@ -550,8 +529,7 @@ static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
int* exit_code) {
int64_t start = Dart_TimelineGetMicros();
ASSERT(script_uri != NULL);
uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_program = NULL;
AppSnapshot* app_snapshot = NULL;
#if defined(DART_PRECOMPILED_RUNTIME)
@@ -585,16 +563,12 @@ static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
}
}
if (!isolate_run_app_snapshot) {
dfe.ReadScript(script_uri, &kernel_buffer, &kernel_buffer_size);
kernel_program = dfe.ReadScript(script_uri);
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
IsolateData* isolate_data =
new IsolateData(script_uri, package_root, packages_config, app_snapshot);
if (kernel_buffer != NULL) {
isolate_data->set_kernel_buffer(kernel_buffer, kernel_buffer_size,
true /*take ownership*/);
}
if (is_main_isolate && (Options::snapshot_deps_filename() != NULL)) {
isolate_data->set_dependencies(new MallocGrowableArray<char*>());
}
@@ -603,23 +577,19 @@ static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
#if !defined(DART_PRECOMPILED_RUNTIME)
if (Options::preview_dart_2()) {
const uint8_t* platform_kernel_buffer = NULL;
intptr_t platform_kernel_buffer_size = 0;
dfe.LoadPlatform(&platform_kernel_buffer, &platform_kernel_buffer_size,
flags->strong);
if (platform_kernel_buffer == NULL) {
platform_kernel_buffer = kernel_buffer;
platform_kernel_buffer_size = kernel_buffer_size;
}
if (platform_kernel_buffer == NULL) {
void* platform_program = dfe.platform_program(flags->strong) != NULL
? dfe.platform_program(flags->strong)
: kernel_program;
if (platform_program == NULL) {
FATAL("platform_program cannot be NULL.");
}
// TODO(sivachandra): When the platform program is unavailable, check if
// application kernel binary is self contained or an incremental binary.
// Isolate should be created only if it is a self contained kernel binary.
isolate = Dart_CreateIsolateFromKernel(
script_uri, main, platform_kernel_buffer, platform_kernel_buffer_size,
flags, isolate_data, error);
isolate = Dart_CreateIsolateFromKernel(script_uri, main, platform_program,
flags, isolate_data, error);
isolate_data->kernel_program = kernel_program;
} else {
isolate = Dart_CreateIsolate(
script_uri, main, isolate_snapshot_data, isolate_snapshot_instructions,
@@ -637,12 +607,7 @@ static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
if (isolate == NULL) {
delete isolate_data;
} else {
#if !defined(DART_PRECOMPILED_RUNTIME)
bool set_native_resolvers =
(kernel_buffer != NULL) || (isolate_snapshot_data != NULL);
#else
bool set_native_resolvers = isolate_snapshot_data != NULL;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
bool set_native_resolvers = (kernel_program || isolate_snapshot_data);
created_isolate =
IsolateSetupHelper(isolate, is_main_isolate, script_uri, package_root,
packages_config, set_native_resolvers,
@@ -651,6 +616,7 @@ static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
int64_t end = Dart_TimelineGetMicros();
Dart_TimelineEvent("CreateIsolateAndSetupHelper", start, end,
Dart_Timeline_Event_Duration, 0, NULL, NULL);
return created_isolate;
}
@@ -1192,14 +1158,10 @@ void main(int argc, char** argv) {
// they might affect how the platform is loaded.
#if !defined(DART_PRECOMPILED_RUNTIME)
dfe.Init();
uint8_t* application_kernel_buffer = NULL;
intptr_t application_kernel_buffer_size = 0;
dfe.ReadScript(script_name, &application_kernel_buffer,
&application_kernel_buffer_size);
if (application_kernel_buffer != NULL) {
void* application_kernel_binary = dfe.ReadScript(script_name);
if (application_kernel_binary != NULL) {
// Since we loaded the script anyway, save it.
dfe.set_application_kernel_buffer(application_kernel_buffer,
application_kernel_buffer_size);
dfe.set_application_kernel_binary(application_kernel_binary);
// Since we saw a dill file, it means we have to turn on all the
// preview_dart_2 options.
Options::SetPreviewDart2Options(&vm_options);
runtime/bin/run_vm_tests.cc
+1 -1
View File
@@ -172,7 +172,7 @@ static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
Dart_EnterScope();
if (isolate_run_script_snapshot) {
uint8_t* payload;
const uint8_t* payload;
intptr_t payload_length;
void* file = bin::DartUtils::OpenFile(script_uri, false);
bin::DartUtils::ReadFile(&payload, &payload_length, file);
runtime/include/dart_api.h
+22 -9
View File
@@ -716,7 +716,7 @@ typedef void (*Dart_ThreadExitCallback)();
*/
typedef void* (*Dart_FileOpenCallback)(const char* name, bool write);
typedef void (*Dart_FileReadCallback)(uint8_t** data,
typedef void (*Dart_FileReadCallback)(const uint8_t** data,
intptr_t* file_length,
void* stream);
@@ -893,14 +893,12 @@ Dart_CreateIsolate(const char* script_uri,
*
* \return The new isolate on success, or NULL if isolate creation failed.
*/
DART_EXPORT Dart_Isolate
Dart_CreateIsolateFromKernel(const char* script_uri,
const char* main,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size,
Dart_IsolateFlags* flags,
void* callback_data,
char** error);
DART_EXPORT Dart_Isolate Dart_CreateIsolateFromKernel(const char* script_uri,
const char* main,
void* kernel_program,
Dart_IsolateFlags* flags,
void* callback_data,
char** error);
/**
* Shuts down the current isolate. After this call, the current isolate is NULL.
* Any current scopes created by Dart_EnterScope will be exited. Invokes the
@@ -2930,6 +2928,21 @@ Dart_LoadScriptFromSnapshot(const uint8_t* script_snapshot_buffer,
DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle
Dart_LoadScriptFromKernel(const uint8_t* kernel_buffer, intptr_t kernel_size);
/**
* Constructs an in-memory kernel program form a binary.
*
* \param buffer The start of a memory buffer containing the binary format.
* \param buffer_len The length of the memory buffer.
* \param callback If not NULL, is called to when buffer is no longer needed.
* If it is NULL, then free() is used to free buffer.
*
* \return kernel_program The `dart::kernel::Program` object.
*/
typedef void (*Dart_ReleaseBufferCallback)(uint8_t* buffer);
DART_EXPORT void* Dart_ReadKernelBinary(const uint8_t* buffer,
intptr_t buffer_len,
Dart_ReleaseBufferCallback callback);
/**
* Gets the library for the root script for the current isolate.
*
runtime/tests/vm/vm.status
+1 -2
View File
@@ -147,8 +147,7 @@ cc/Service_TokenStream: Fail
[ $compiler == dartk && $runtime == vm ]
cc/Class_ComputeEndTokenPos: Crash
cc/DartAPI_IsolateShutdownRunDartCode: Skip # Flaky
cc/DartAPI_LazyLoadDeoptimizes: Fail
cc/DartAPI_LoadLibrary: Fail, Crash # Issue 33048.
cc/DartAPI_LoadLibrary: Crash # Issue 33048.
cc/DebuggerAPI_BreakpointStubPatching: Fail
cc/DebuggerAPI_GetClosureInfo: Fail
cc/DebuggerAPI_InterruptIsolate: SkipSlow
runtime/vm/bootstrap.cc
+5 -14
View File
@@ -310,12 +310,8 @@ static RawError* BootstrapFromSource(Thread* thread) {
}
#if !defined(DART_PRECOMPILED_RUNTIME)
static RawError* BootstrapFromKernel(Thread* thread,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
static RawError* BootstrapFromKernel(Thread* thread, kernel::Program* program) {
Zone* zone = thread->zone();
kernel::Program* program =
kernel::Program::ReadFromBuffer(kernel_buffer, kernel_buffer_size, false);
kernel::KernelLoader loader(program);
Isolate* isolate = thread->isolate();
@@ -341,7 +337,6 @@ static RawError* BootstrapFromKernel(Thread* thread,
// The platform binary may contain other libraries (e.g., dart:_builtin or
// dart:io) that will not be bundled with application. Load them now.
const Object& result = loader.LoadProgram();
delete program;
if (result.IsError()) {
return Error::Cast(result).raw();
}
@@ -354,16 +349,13 @@ static RawError* BootstrapFromKernel(Thread* thread,
return Error::null();
}
#else
static RawError* BootstrapFromKernel(Thread* thread,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
static RawError* BootstrapFromKernel(Thread* thread, kernel::Program* program) {
UNREACHABLE();
return Error::null();
}
#endif
RawError* Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
RawError* Bootstrap::DoBootstrapping(kernel::Program* kernel_program) {
Thread* thread = Thread::Current();
Isolate* isolate = thread->isolate();
Zone* zone = thread->zone();
@@ -386,9 +378,8 @@ RawError* Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
}
}
return (kernel_buffer == NULL)
? BootstrapFromSource(thread)
: BootstrapFromKernel(thread, kernel_buffer, kernel_buffer_size);
return (kernel_program == NULL) ? BootstrapFromSource(thread)
: BootstrapFromKernel(thread, kernel_program);
}
} // namespace dart
runtime/vm/bootstrap.h
+1 -2
View File
@@ -24,8 +24,7 @@ class Bootstrap : public AllStatic {
// bootstrapping.
// The caller of this function is responsible for managing the kernel
// program's memory.
static RawError* DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size);
static RawError* DoBootstrapping(kernel::Program* program);
static void SetupNativeResolver();
static bool IsBootstapResolver(Dart_NativeEntryResolver resolver);
runtime/vm/bootstrap_nocore.cc
+4 -11
View File
@@ -70,12 +70,8 @@ static void Finish(Thread* thread) {
Compiler::CompileClass(cls);
}
RawError* BootstrapFromKernel(Thread* thread,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
RawError* BootstrapFromKernel(Thread* thread, kernel::Program* program) {
Zone* zone = thread->zone();
kernel::Program* program =
kernel::Program::ReadFromBuffer(kernel_buffer, kernel_buffer_size, false);
kernel::KernelLoader loader(program);
Isolate* isolate = thread->isolate();
@@ -101,7 +97,6 @@ RawError* BootstrapFromKernel(Thread* thread,
// The platform binary may contain other libraries (e.g., dart:_builtin or
// dart:io) that will not be bundled with application. Load them now.
const Object& result = loader.LoadProgram();
delete program;
if (result.IsError()) {
return Error::Cast(result).raw();
}
@@ -114,8 +109,7 @@ RawError* BootstrapFromKernel(Thread* thread,
return Error::null();
}
RawError* Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
RawError* Bootstrap::DoBootstrapping(kernel::Program* program) {
Thread* thread = Thread::Current();
Isolate* isolate = thread->isolate();
Zone* zone = thread->zone();
@@ -138,11 +132,10 @@ RawError* Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
}
}
return BootstrapFromKernel(thread, kernel_buffer, kernel_buffer_size);
return BootstrapFromKernel(thread, program);
}
#else
RawError* Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
RawError* Bootstrap::DoBootstrapping(kernel::Program* program) {
UNREACHABLE();
return Error::null();
}
runtime/vm/dart.cc
+6 -6
View File
@@ -504,8 +504,8 @@ RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
const uint8_t* snapshot_instructions,
const uint8_t* shared_data,
const uint8_t* shared_instructions,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size,
intptr_t snapshot_length,
kernel::Program* kernel_program,
void* data) {
// Initialize the new isolate.
Thread* T = Thread::Current();
@@ -524,11 +524,11 @@ RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
}
Error& error = Error::Handle(T->zone());
error = Object::Init(I, kernel_buffer, kernel_buffer_size);
error = Object::Init(I, kernel_program);
if (!error.IsNull()) {
return error.raw();
}
if ((snapshot_data != NULL) && kernel_buffer == NULL) {
if ((snapshot_data != NULL) && kernel_program == NULL) {
// Read the snapshot and setup the initial state.
NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
"IsolateSnapshotReader"));
@@ -567,7 +567,7 @@ RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
MegamorphicCacheTable::PrintSizes(I);
}
} else {
if ((vm_snapshot_kind_ != Snapshot::kNone) && kernel_buffer == NULL) {
if ((vm_snapshot_kind_ != Snapshot::kNone) && kernel_program == NULL) {
const String& message =
String::Handle(String::New("Missing isolate snapshot"));
return ApiError::New(message);
@@ -592,7 +592,7 @@ RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
Code::Handle(I->object_store()->megamorphic_miss_code());
I->set_ic_miss_code(miss_code);
if ((snapshot_data == NULL) || (kernel_buffer != NULL)) {
if ((snapshot_data == NULL) || (kernel_program != NULL)) {
const Error& error = Error::Handle(I->object_store()->PreallocateObjects());
if (!error.IsNull()) {
return error.raw();
runtime/vm/dart.h
+2 -2
View File
@@ -50,8 +50,8 @@ class Dart : public AllStatic {
const uint8_t* snapshot_instructions,
const uint8_t* shared_data,
const uint8_t* shared_instructions,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size,
intptr_t snapshot_length,
kernel::Program* kernel_program,
void* data);
static void RunShutdownCallback();
static void ShutdownIsolate(Isolate* isolate);
runtime/vm/dart_api_impl.cc
+72 -24
View File
@@ -1101,8 +1101,8 @@ static Dart_Isolate CreateIsolate(const char* script_uri,
const uint8_t* snapshot_instructions,
const uint8_t* shared_data,
const uint8_t* shared_instructions,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size,
intptr_t snapshot_length,
kernel::Program* kernel_program,
Dart_IsolateFlags* flags,
void* callback_data,
char** error) {
@@ -1131,14 +1131,14 @@ static Dart_Isolate CreateIsolate(const char* script_uri,
// bootstrap library files which call out to a tag handler that may create
// Api Handles when an error is encountered.
Dart_EnterScope();
const Error& error_obj = Error::Handle(
Z,
Dart::InitializeIsolate(snapshot_data, snapshot_instructions,
shared_data, shared_instructions, kernel_buffer,
kernel_buffer_size, callback_data));
const Error& error_obj =
Error::Handle(Z, Dart::InitializeIsolate(
snapshot_data, snapshot_instructions, shared_data,
shared_instructions, snapshot_length,
kernel_program, callback_data));
if (error_obj.IsNull()) {
#if defined(DART_NO_SNAPSHOT) && !defined(PRODUCT)
if (FLAG_check_function_fingerprints && kernel_buffer == NULL) {
if (FLAG_check_function_fingerprints && kernel_program == NULL) {
Library::CheckFunctionFingerprints();
}
#endif // defined(DART_NO_SNAPSHOT) && !defined(PRODUCT).
@@ -1181,18 +1181,16 @@ Dart_CreateIsolate(const char* script_uri,
char** error) {
API_TIMELINE_DURATION(Thread::Current());
return CreateIsolate(script_uri, main, snapshot_data, snapshot_instructions,
shared_data, shared_instructions, NULL, 0, flags,
shared_data, shared_instructions, -1, NULL, flags,
callback_data, error);
}
DART_EXPORT Dart_Isolate
Dart_CreateIsolateFromKernel(const char* script_uri,
const char* main,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size,
Dart_IsolateFlags* flags,
void* callback_data,
char** error) {
DART_EXPORT Dart_Isolate Dart_CreateIsolateFromKernel(const char* script_uri,
const char* main,
void* kernel_program,
Dart_IsolateFlags* flags,
void* callback_data,
char** error) {
API_TIMELINE_DURATION(Thread::Current());
// Setup default flags in case none were passed.
Dart_IsolateFlags api_flags;
@@ -1201,8 +1199,9 @@ Dart_CreateIsolateFromKernel(const char* script_uri,
flags = &api_flags;
}
flags->use_dart_frontend = true;
return CreateIsolate(script_uri, main, NULL, NULL, NULL, NULL, kernel_buffer,
kernel_buffer_size, flags, callback_data, error);
return CreateIsolate(script_uri, main, NULL, NULL, NULL, NULL, -1,
reinterpret_cast<kernel::Program*>(kernel_program),
flags, callback_data, error);
}
DART_EXPORT void Dart_ShutdownIsolate() {
@@ -5154,6 +5153,17 @@ static void CompileSource(Thread* thread,
lib.SetLoadError(Object::null_instance());
}
}
static Dart_Handle LoadKernelProgram(Thread* T,
const String& url,
void* kernel) {
// NOTE: Now the VM owns the [kernel_program] memory!
// We will promptly delete it when done.
kernel::Program* program = reinterpret_cast<kernel::Program*>(kernel);
const Object& tmp = kernel::KernelLoader::LoadEntireProgram(program);
delete program;
return Api::NewHandle(T, tmp.raw());
}
#endif // !defined(DART_PRECOMPILED_RUNTIME)
DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
@@ -5197,8 +5207,27 @@ DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
Dart_Handle result;
if (I->use_dart_frontend()) {
return Api::NewError("%s: Should not be called with using Dart frontend",
CURRENT_FUNC);
// TODO(kernel): Fix callers to use Dart_LoadScriptFromKernel.
if ((source == Api::Null()) || (source == NULL)) {
RETURN_NULL_ERROR(source);
}
void* kernel_pgm = reinterpret_cast<void*>(source);
result = LoadKernelProgram(T, resolved_url_str, kernel_pgm);
if (::Dart_IsError(result)) {
return result;
}
library ^= Library::LookupLibrary(T, resolved_url_str);
if (library.IsNull()) {
// If the URL string does not match, use the library object
// returned by the kernel loader.
library ^= Api::UnwrapHandle(result);
}
if (library.IsNull()) {
return Api::NewError("%s: Unable to load script '%s' correctly.",
CURRENT_FUNC, resolved_url_str.ToCString());
}
I->object_store()->set_root_library(library);
return Api::NewHandle(T, library.raw());
}
const String& source_str = Api::UnwrapStringHandle(Z, source);
@@ -5290,6 +5319,20 @@ DART_EXPORT Dart_Handle Dart_LoadScriptFromSnapshot(const uint8_t* buffer,
#endif // defined(DART_PRECOMPILED_RUNTIME)
}
DART_EXPORT void* Dart_ReadKernelBinary(const uint8_t* buffer,
intptr_t buffer_len,
Dart_ReleaseBufferCallback callback) {
#if defined(DART_PRECOMPILED_RUNTIME)
UNREACHABLE();
return NULL;
#else
kernel::Program* program =
kernel::Program::ReadFromBuffer(buffer, buffer_len);
program->set_release_buffer_callback(callback);
return program;
#endif
}
DART_EXPORT Dart_Handle Dart_LoadScriptFromKernel(const uint8_t* buffer,
intptr_t buffer_size) {
#if defined(DART_PRECOMPILED_RUNTIME)
@@ -5317,7 +5360,7 @@ DART_EXPORT Dart_Handle Dart_LoadScriptFromKernel(const uint8_t* buffer,
if (tmp.IsError()) {
return Api::NewHandle(T, tmp.raw());
}
// TODO(32618): Setting root library based on whether it has 'main' or not
// TODO(kernel): Setting root library based on whether it has 'main' or not
// is not correct because main can be in the exported namespace of a library
// or it could be a getter.
if (tmp.IsNull()) {
@@ -5533,8 +5576,13 @@ DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle url,
}
Dart_Handle result;
if (I->use_dart_frontend()) {
return Api::NewError("%s: Should not be called with using Dart frontend",
CURRENT_FUNC);
// TODO(kernel): Fix callers to use Dart_LoadLibraryFromKernel.
void* kernel_pgm = reinterpret_cast<void*>(source);
result = LoadKernelProgram(T, url_str, kernel_pgm);
if (::Dart_IsError(result)) {
return result;
}
return Api::NewHandle(T, Library::LookupLibrary(T, url_str));
}
if (::Dart_IsNull(resolved_url)) {
resolved_url = url;
runtime/vm/dart_api_impl_test.cc
+7 -6
View File
@@ -3394,20 +3394,21 @@ VM_UNIT_TEST_CASE(DartAPI_CurrentIsolateData) {
static Dart_Handle LoadScript(const char* url_str, const char* source) {
Dart_Handle url = NewString(url_str);
Dart_Handle result;
Dart_Handle script;
if (!FLAG_use_dart_frontend) {
result = Dart_SetLibraryTagHandler(TestCase::library_handler);
EXPECT_VALID(result);
return Dart_LoadScript(url, Dart_Null(), NewString(source), 0, 0);
script = NewString(source);
} else {
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
char* error = TestCase::CompileTestScriptWithDFE(
url_str, source, &kernel_buffer, &kernel_buffer_size);
void* kernel_pgm = NULL;
char* error =
TestCase::CompileTestScriptWithDFE(url_str, source, &kernel_pgm);
if (error != NULL) {
return Dart_NewApiError(error);
}
return Dart_LoadScriptFromKernel(kernel_buffer, kernel_buffer_size);
script = reinterpret_cast<Dart_Handle>(kernel_pgm);
}
return Dart_LoadScript(url, Dart_Null(), script, 0, 0);
}
VM_UNIT_TEST_CASE(DartAPI_IsolateSetCheckedMode) {
runtime/vm/isolate_reload.cc
+2 -2
View File
@@ -614,8 +614,8 @@ void IsolateReloadContext::Reload(bool force_reload,
return;
}
did_kernel_compilation = true;
kernel_program.set(kernel::Program::ReadFromBuffer(
retval.kernel, retval.kernel_size, true));
kernel_program.set(
kernel::Program::ReadFromBuffer(retval.kernel, retval.kernel_size));
}
kernel_program.get()->set_release_buffer_callback(ReleaseFetchedBytes);
runtime/vm/isolate_reload_test.cc
+12 -18
View File
@@ -123,17 +123,15 @@ TEST_CASE(IsolateReload_KernelIncrementalCompile) {
}};
// clang-format on
{
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_pgm = NULL;
char* error = TestCase::CompileTestScriptWithDFE(
"file:///test-app",
sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
true /* incrementally */);
updated_sourcefiles, &kernel_pgm, true /* incrementally */);
EXPECT(error == NULL);
EXPECT_NOTNULL(kernel_buffer);
EXPECT_NOTNULL(kernel_pgm);
lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
lib = TestCase::ReloadTestKernel(kernel_pgm);
EXPECT_VALID(lib);
}
result = Dart_Invoke(lib, NewString("main"), 0, NULL);
@@ -184,17 +182,15 @@ TEST_CASE(IsolateReload_KernelIncrementalCompileAppAndLib) {
}};
// clang-format on
{
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_pgm = NULL;
char* error = TestCase::CompileTestScriptWithDFE(
"file:///test-app.dart",
sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
true /* incrementally */);
updated_sourcefiles, &kernel_pgm, true /* incrementally */);
EXPECT(error == NULL);
EXPECT_NOTNULL(kernel_buffer);
EXPECT_NOTNULL(kernel_pgm);
lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
lib = TestCase::ReloadTestKernel(kernel_pgm);
EXPECT_VALID(lib);
}
result = Dart_Invoke(lib, NewString("main"), 0, NULL);
@@ -261,17 +257,15 @@ TEST_CASE(IsolateReload_KernelIncrementalCompileGenerics) {
}};
// clang-format on
{
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_pgm = NULL;
char* error = TestCase::CompileTestScriptWithDFE(
"file:///test-app.dart",
sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile),
updated_sourcefiles, &kernel_buffer, &kernel_buffer_size,
true /* incrementally */);
updated_sourcefiles, &kernel_pgm, true /* incrementally */);
EXPECT(error == NULL);
EXPECT_NOTNULL(kernel_buffer);
EXPECT_NOTNULL(kernel_pgm);
lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size);
lib = TestCase::ReloadTestKernel(kernel_pgm);
EXPECT_VALID(lib);
}
result = Dart_Invoke(lib, NewString("main"), 0, NULL);
runtime/vm/kernel.h
+2 -5
View File
@@ -55,8 +55,6 @@ const uint8_t kNativeYieldFlags = 0x2;
enum LogicalOperator { kAnd, kOr };
typedef void (*Dart_ReleaseBufferCallback)(uint8_t* buffer);
class Program {
public:
~Program() {
@@ -79,12 +77,12 @@ class Program {
* "sub program" should not try to release the buffer.
* @return
*/
static Program* ReadFrom(Reader* reader, bool take_buffer_ownership = false);
static Program* ReadFrom(Reader* reader, bool take_buffer_ownership = true);
static Program* ReadFromFile(const char* script_uri);
static Program* ReadFromBuffer(const uint8_t* buffer,
intptr_t buffer_length,
bool take_buffer_ownership = false);
bool take_buffer_ownership = true);
bool is_single_program() { return single_program_; }
NameIndex main_method() { return main_method_reference_; }
@@ -196,7 +194,6 @@ class KernelLineStartsReader {
const dart::TypedData& line_starts_data_;
KernelLineStartsHelper* helper_;
Dart_ReleaseBufferCallback release_callback;
DISALLOW_COPY_AND_ASSIGN(KernelLineStartsReader);
};
runtime/vm/kernel_binary.cc
+6 -14
View File
@@ -90,25 +90,17 @@ Program* Program::ReadFromFile(const char* script_uri) {
Dart_kKernelTag, Api::Null(),
Api::NewHandle(thread, String::New(script_uri)));
if (!Dart_IsError(retval)) {
uint64_t data;
intptr_t data_len = 0;
Dart_TypedData_Type data_type;
uint8_t* data;
ASSERT(Dart_IsTypedData(retval));
uint8_t* kernel_buffer;
intptr_t kernel_buffer_size;
Dart_Handle val = Dart_TypedDataAcquireData(
retval, &data_type, reinterpret_cast<void**>(&data),
&kernel_buffer_size);
retval, &data_type, reinterpret_cast<void**>(&data), &data_len);
ASSERT(!Dart_IsError(val));
ASSERT(data_type == Dart_TypedData_kUint8);
kernel_buffer = reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size));
memmove(kernel_buffer, data, kernel_buffer_size);
ASSERT(data_type == Dart_TypedData_kUint64);
ASSERT(data_len == 1);
kernel_program = reinterpret_cast<kernel::Program*>(data);
Dart_TypedDataReleaseData(retval);
kernel_program =
kernel::Program::ReadFromBuffer(kernel_buffer, kernel_buffer_size);
} else {
THR_Print("tag handler failed: %s\n", Dart_GetError(retval));
}
}
return kernel_program;
runtime/vm/object.cc
+4 -6
View File
@@ -1293,14 +1293,12 @@ void Object::RegisterPrivateClass(const Class& cls,
// A non-NULL kernel argument indicates (1). A NULL kernel indicates (2) or
// (3), depending on whether the VM is compiled with DART_NO_SNAPSHOT defined or
// not.
RawError* Object::Init(Isolate* isolate,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
RawError* Object::Init(Isolate* isolate, kernel::Program* kernel_program) {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
ASSERT(isolate == thread->isolate());
#if !defined(DART_PRECOMPILED_RUNTIME)
const bool is_kernel = (kernel_buffer != NULL);
const bool is_kernel = (kernel_program != NULL);
#endif
NOT_IN_PRODUCT(TimelineDurationScope tds(thread, Timeline::GetIsolateStream(),
"Object::Init");)
@@ -1815,8 +1813,8 @@ RawError* Object::Init(Isolate* isolate,
// Finish the initialization by compiling the bootstrap scripts containing
// the base interfaces and the implementation of the internal classes.
const Error& error = Error::Handle(
zone, Bootstrap::DoBootstrapping(kernel_buffer, kernel_buffer_size));
const Error& error =
Error::Handle(zone, Bootstrap::DoBootstrapping(kernel_program));
if (!error.IsNull()) {
return error.raw();
}
runtime/vm/object.h
+1 -3
View File
@@ -558,9 +558,7 @@ class Object {
// Initialize a new isolate either from a Kernel IR, from source, or from a
// snapshot.
static RawError* Init(Isolate* isolate,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size);
static RawError* Init(Isolate* isolate, kernel::Program* program);
static void MakeUnusedSpaceTraversable(const Object& obj,
intptr_t original_size,
runtime/vm/unit_test.cc
+38 -41
View File
@@ -81,6 +81,8 @@ void TestCaseBase::RunAll() {
}
}
static void NoopRelease(uint8_t* data) {}
Dart_Isolate TestCase::CreateIsolate(const uint8_t* data_buffer,
intptr_t len,
const uint8_t* instr_buffer,
@@ -95,8 +97,13 @@ Dart_Isolate TestCase::CreateIsolate(const uint8_t* data_buffer,
isolate = Dart_CreateIsolate(name, NULL, data_buffer, instr_buffer, NULL,
NULL, &api_flags, data, &err);
} else {
isolate = Dart_CreateIsolateFromKernel(name, NULL, data_buffer, len,
&api_flags, data, &err);
kernel::Program* program = reinterpret_cast<kernel::Program*>(
Dart_ReadKernelBinary(data_buffer, len, NoopRelease));
if (program != NULL) {
isolate = Dart_CreateIsolateFromKernel(name, NULL, program, &api_flags,
data, &err);
delete program;
}
}
if (isolate == NULL) {
OS::PrintErr("Creation of isolate failed '%s'\n", err);
@@ -230,8 +237,7 @@ bool TestCase::UsingStrongMode() {
char* TestCase::CompileTestScriptWithDFE(const char* url,
const char* source,
const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
void** kernel_pgm,
bool incrementally) {
// clang-format off
Dart_SourceFile sourcefiles[] = {
@@ -242,16 +248,19 @@ char* TestCase::CompileTestScriptWithDFE(const char* url,
"file:///.packages", "untitled:/"
}};
// clang-format on
return CompileTestScriptWithDFE(
url, sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles,
kernel_buffer, kernel_buffer_size, incrementally);
return CompileTestScriptWithDFE(url,
sizeof(sourcefiles) / sizeof(Dart_SourceFile),
sourcefiles, kernel_pgm, incrementally);
}
static void ReleaseFetchedBytes(uint8_t* buffer) {
free(buffer);
}
char* TestCase::CompileTestScriptWithDFE(const char* url,
int sourcefiles_count,
Dart_SourceFile sourcefiles[],
const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
void** kernel_pgm,
bool incrementally) {
Zone* zone = Thread::Current()->zone();
Dart_KernelCompilationResult compilation_result = Dart_CompileSourcesToKernel(
@@ -265,11 +274,16 @@ char* TestCase::CompileTestScriptWithDFE(const char* url,
free(compilation_result.error);
return result;
}
*kernel_buffer = compilation_result.kernel;
*kernel_buffer_size = compilation_result.kernel_size;
if (kernel_buffer == NULL) {
const uint8_t* kernel_file = compilation_result.kernel;
intptr_t kernel_length = compilation_result.kernel_size;
if (kernel_file == NULL) {
return OS::SCreate(zone, "front end generated a NULL kernel file");
}
*kernel_pgm =
Dart_ReadKernelBinary(kernel_file, kernel_length, ReleaseFetchedBytes);
if (*kernel_pgm == NULL) {
return OS::SCreate(zone, "Failed to read generated kernel binary");
}
return NULL;
}
@@ -442,25 +456,17 @@ Dart_Handle TestCase::LoadTestLibrary(const char* lib_uri,
const char* prefixed_lib_uri =
OS::SCreate(Thread::Current()->zone(), "file:///%s", lib_uri);
Dart_SourceFile sourcefiles[] = {{prefixed_lib_uri, script}};
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_pgm = NULL;
int sourcefiles_count = sizeof(sourcefiles) / sizeof(Dart_SourceFile);
char* error = TestCase::CompileTestScriptWithDFE(
sourcefiles[0].uri, sourcefiles_count, sourcefiles, &kernel_buffer,
&kernel_buffer_size, true);
sourcefiles[0].uri, sourcefiles_count, sourcefiles, &kernel_pgm, true);
if (error != NULL) {
return Dart_NewApiError(error);
}
Dart_Handle lib =
Dart_LoadLibraryFromKernel(kernel_buffer, kernel_buffer_size);
Dart_Handle url = NewString(prefixed_lib_uri);
Dart_Handle lib = Dart_LoadLibrary(
url, Dart_Null(), reinterpret_cast<Dart_Handle>(kernel_pgm), 0, 0);
EXPECT_VALID(lib);
// TODO(32618): Kernel doesn't correctly represent the root library.
lib = Dart_LookupLibrary(Dart_NewStringFromCString(sourcefiles[0].uri));
DART_CHECK_VALID(lib);
Dart_Handle result = Dart_SetRootLibrary(lib);
DART_CHECK_VALID(result);
Dart_SetNativeResolver(lib, resolver, NULL);
return lib;
} else {
@@ -476,27 +482,19 @@ Dart_Handle TestCase::LoadTestScriptWithDFE(int sourcefiles_count,
bool finalize,
bool incrementally) {
// First script is the main script.
Dart_Handle url = NewString(sourcefiles[0].uri);
Dart_Handle result = Dart_SetLibraryTagHandler(LibraryTagHandler);
EXPECT_VALID(result);
const uint8_t* kernel_buffer = NULL;
intptr_t kernel_buffer_size = 0;
void* kernel_pgm = NULL;
char* error = TestCase::CompileTestScriptWithDFE(
sourcefiles[0].uri, sourcefiles_count, sourcefiles, &kernel_buffer,
&kernel_buffer_size, incrementally);
sourcefiles[0].uri, sourcefiles_count, sourcefiles, &kernel_pgm,
incrementally);
if (error != NULL) {
return Dart_NewApiError(error);
}
Dart_Handle lib =
Dart_LoadLibraryFromKernel(kernel_buffer, kernel_buffer_size);
Dart_Handle lib = Dart_LoadScript(
url, Dart_Null(), reinterpret_cast<Dart_Handle>(kernel_pgm), 0, 0);
DART_CHECK_VALID(lib);
// BOGUS: Kernel doesn't correctly represent the root library.
lib = Dart_LookupLibrary(Dart_NewStringFromCString(sourcefiles[0].uri));
DART_CHECK_VALID(lib);
result = Dart_SetRootLibrary(lib);
DART_CHECK_VALID(result);
result = Dart_SetNativeResolver(lib, resolver, NULL);
DART_CHECK_VALID(result);
if (finalize) {
@@ -588,8 +586,7 @@ Dart_Handle TestCase::ReloadTestScript(const char* script) {
return TriggerReload();
}
Dart_Handle TestCase::ReloadTestKernel(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
Dart_Handle TestCase::ReloadTestKernel(const void* kernel) {
return TriggerReload();
}
runtime/vm/unit_test.h
+3 -6
View File
@@ -316,14 +316,12 @@ class TestCase : TestCaseBase {
static char* CompileTestScriptWithDFE(const char* url,
const char* source,
const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
void** kernel_pgm,
bool incrementally = true);
static char* CompileTestScriptWithDFE(const char* url,
int sourcefiles_count,
Dart_SourceFile sourcefiles[],
const uint8_t** kernel_buffer,
intptr_t* kernel_buffer_size,
void** kernel_pgm,
bool incrementally = true);
static Dart_Handle LoadTestScript(const char* script,
Dart_NativeEntryResolver resolver,
@@ -364,8 +362,7 @@ class TestCase : TestCaseBase {
// Helper function which reloads the current isolate using |script|.
static Dart_Handle ReloadTestScript(const char* script);
static Dart_Handle ReloadTestKernel(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size);
static Dart_Handle ReloadTestKernel(const void* kernel);
static void AddTestLib(const char* url, const char* source);
static const char* GetTestLib(const char* url);
tests/language_2/language_2_kernel.status
-1
View File
@@ -582,7 +582,6 @@ disassemble_test: Pass, Slow
dynamic_prefix_core_test/none: CompileTimeError
emit_const_fields_test: CompileTimeError # Issue 31533
example_constructor_test: Fail, OK
export_ambiguous_main_test: Crash # Issue 32618
external_test/10: MissingRuntimeError # KernelVM bug: Unbound external.
external_test/13: MissingRuntimeError # KernelVM bug: Unbound external.
external_test/20: MissingRuntimeError # KernelVM bug: Unbound external.