blob: 5e3ddd7a68554fba097822755c449b80a8933165 [file] [log] [blame]
// Copyright (c) 2012, 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 "vm/bootstrap.h"
#include <memory>
#include "include/dart_api.h"
#include "vm/class_finalizer.h"
#include "vm/compiler/jit/compiler.h"
#include "vm/dart_api_impl.h"
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "vm/kernel.h"
#include "vm/kernel_loader.h"
#endif
#include "vm/longjump.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/symbols.h"
namespace dart {
struct BootstrapLibProps {
ObjectStore::BootstrapLibraryId index;
const char* uri;
};
enum { kPathsUriOffset = 0, kPathsSourceOffset = 1, kPathsEntryLength = 2 };
#if !defined(DART_PRECOMPILED_RUNTIME)
#define MAKE_PROPERTIES(CamelName, name) \
{ObjectStore::k##CamelName, "dart:" #name},
static const BootstrapLibProps bootstrap_libraries[] = {
FOR_EACH_BOOTSTRAP_LIBRARY(MAKE_PROPERTIES)};
#undef MAKE_PROPERTIES
static const intptr_t kBootstrapLibraryCount = ARRAY_SIZE(bootstrap_libraries);
static void Finish(Thread* thread) {
Bootstrap::SetupNativeResolver();
if (!ClassFinalizer::ProcessPendingClasses()) {
FATAL("Error in class finalization during bootstrapping.");
}
// Eagerly compile the _Closure class as it is the class of all closure
// instances. This allows us to just finalize function types without going
// through the hoops of trying to compile their scope class.
ObjectStore* object_store = thread->isolate_group()->object_store();
Zone* zone = thread->zone();
Class& cls = Class::Handle(zone, object_store->closure_class());
cls.EnsureIsFinalized(thread);
// Make sure _Closure fields are not marked as unboxing candidates
// as they are accessed with plain loads.
const Array& fields = Array::Handle(zone, cls.fields());
Field& field = Field::Handle(zone);
for (intptr_t i = 0; i < fields.Length(); ++i) {
field ^= fields.At(i);
field.set_is_unboxing_candidate(false);
}
// _Closure._hash field should be explicitly marked as nullable because
// VM creates instances of _Closure without compiling its constructors,
// so it won't get nullability info from a constructor.
field ^= fields.At(fields.Length() - 1);
// Note that UserVisibleName depends on --show-internal-names.
ASSERT(strncmp(field.UserVisibleNameCString(), "_hash", 5) == 0);
field.RecordStore(Object::null_object());
#if defined(DEBUG)
// Verify that closure field offsets are identical in Dart and C++.
ASSERT(fields.Length() == 6);
field ^= fields.At(0);
ASSERT(field.HostOffset() == Closure::instantiator_type_arguments_offset());
field ^= fields.At(1);
ASSERT(field.HostOffset() == Closure::function_type_arguments_offset());
field ^= fields.At(2);
ASSERT(field.HostOffset() == Closure::delayed_type_arguments_offset());
field ^= fields.At(3);
ASSERT(field.HostOffset() == Closure::function_offset());
field ^= fields.At(4);
ASSERT(field.HostOffset() == Closure::context_offset());
field ^= fields.At(5);
ASSERT(field.HostOffset() == Closure::hash_offset());
#endif // defined(DEBUG)
// Eagerly compile Bool class, bool constants are used from within compiler.
cls = object_store->bool_class();
cls.EnsureIsFinalized(thread);
}
static ErrorPtr BootstrapFromKernel(Thread* thread,
const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
Zone* zone = thread->zone();
const char* error = nullptr;
std::unique_ptr<kernel::Program> program = kernel::Program::ReadFromBuffer(
kernel_buffer, kernel_buffer_size, &error);
if (program == nullptr) {
const intptr_t kMessageBufferSize = 512;
char message_buffer[kMessageBufferSize];
Utils::SNPrint(message_buffer, kMessageBufferSize,
"Can't load Kernel binary: %s.", error);
const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
return ApiError::New(msg, Heap::kOld);
}
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
kernel::KernelLoader loader(program.get(), /*uri_to_source_table=*/nullptr);
auto isolate_group = thread->isolate_group();
if (isolate_group->obfuscate()) {
loader.ReadObfuscationProhibitions();
}
// Load the bootstrap libraries in order (see object_store.h).
Library& library = Library::Handle(zone);
for (intptr_t i = 0; i < kBootstrapLibraryCount; ++i) {
ObjectStore::BootstrapLibraryId id = bootstrap_libraries[i].index;
library = isolate_group->object_store()->bootstrap_library(id);
loader.LoadLibrary(library);
}
// Finish bootstrapping, including class finalization.
Finish(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 = Object::Handle(zone, loader.LoadProgram());
program.reset();
if (result.IsError()) {
return Error::Cast(result).ptr();
}
// The builtin library should be registered with the VM.
const auto& dart_builtin =
String::Handle(zone, String::New("dart:_builtin"));
library = Library::LookupLibrary(thread, dart_builtin);
isolate_group->object_store()->set_builtin_library(library);
if (FLAG_precompiled_mode) {
loader.ReadLoadingUnits();
}
return Error::null();
}
// Either class finalization failed or we caught a compile-time error.
// In both cases sticky error would be set.
return Thread::Current()->StealStickyError();
}
ErrorPtr Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
Thread* thread = Thread::Current();
auto isolate_group = thread->isolate_group();
Zone* zone = thread->zone();
String& uri = String::Handle(zone);
Library& lib = Library::Handle(zone);
HANDLESCOPE(thread);
// Ensure there are library objects for all the bootstrap libraries.
for (intptr_t i = 0; i < kBootstrapLibraryCount; ++i) {
ObjectStore::BootstrapLibraryId id = bootstrap_libraries[i].index;
uri = Symbols::New(thread, bootstrap_libraries[i].uri);
lib = isolate_group->object_store()->bootstrap_library(id);
ASSERT(lib.ptr() == Library::LookupLibrary(thread, uri));
if (lib.IsNull()) {
lib = Library::NewLibraryHelper(uri, false);
lib.SetLoadRequested();
lib.Register(thread);
isolate_group->object_store()->set_bootstrap_library(id, lib);
}
}
return BootstrapFromKernel(thread, kernel_buffer, kernel_buffer_size);
}
#else
ErrorPtr Bootstrap::DoBootstrapping(const uint8_t* kernel_buffer,
intptr_t kernel_buffer_size) {
UNREACHABLE();
return Error::null();
}
#endif
} // namespace dart